javascript复制代码import pandas as pd

ini复制代码data = pd.read_csv( my_file.csv )
data = pd.read_csv( my_file.csv , sep= ; , encoding= latin-1 , nrows=1000, skiprows=[2,5])

ini复制代码data.to_csv( my_new_file.csv , index=None)

arduino复制代码Gives (#rows, #columns)

kotlin复制代码data.describe()

kotlin复制代码data.head(3)

css复制代码data.loc[8]

css复制代码data.loc[8,  column_1 ]

css复制代码data.loc[range(4,6)]

kotlin复制代码data[data[ column_1 ]== french ]
data[(data[ column_1 ]== french ) & (data[ year_born ]==1990)]
data[(data[ column_1 ]== french ) & (data[ year_born ]==1990) & ~(data[ city ]== London )]

css复制代码data[data[ column_1 ].isin([ french ,  english ])]

scss复制代码data[ column_numerical ].plot()

scss复制代码data[ column_numerical ].hist()

scala复制代码%matplotlib inline

css复制代码data.loc[8,  column_1 ] =  english
将第八行名为 column_1 的列替换为「english」

kotlin复制代码data.loc[data[ column_1 ]== french ,  column_1 ] =  French

scss复制代码data[ column_1 ].value_counts()

go复制代码data[ column_1 ].map(len)

python复制代码data[ column_1 ].map(len).map(lambda x: x/100).plot()

arduino复制代码data.apply(sum)

csharp复制代码from tqdm import tqdm_notebook
tqdm_notebook().pandas()

less复制代码data[ column_1 ].progress_map(lambda x: x.count( e ))

scss复制代码data.corr()
data.corr().applymap(lambda x: int(x*100)/100)

ini复制代码pd.plotting.scatter_matrix(data, figsize=(12,8))

ini复制代码data.merge(other_data, on=[ column_1 ,  column_2 ,  column_3 ])

scss复制代码data.groupby( column_1 )[ column_2 ].apply(sum).reset_index()

ini复制代码dictionary = {}

for i,row in data.iterrows():
 dictionary[row[ column_1 ]] = row[ column_2 ]

docker复制代码docker pull jenkins/jenkins:lts

docker复制代码docker run --name jenkins --user=root -p 8080:8080 -p 50000:50000 -v /Users/wei/Documents/jenkins_home:/var/jenkins_home -d jenkins/jenkins:lts

docker复制代码docker rm -f $(docker ps -a |  grep "jenkins"  | awk '{print $1}')

ini复制代码CarPo carPo = this.carDao.selectById(1L);
CarVo carVo = new CarVo();
carVo.setId(carPo.getId());
carVo.setName(carPo.getName());
//省略一堆
return carVo;

ini复制代码CarPo carPo = this.carDao.selectById(1L);
CarVo carVo = new CarVo();
BeanUtils.copyProperties(carPo, carVo);
return carVo;

ini复制代码@Mapping(source = "carName", target = "name")，

less复制代码carVo.setName(carPo.getCarName())

xml复制代码<dependency>
    <groupId>org.mapstruct</groupId>
    <!-- jdk8以下就使用mapstruct -->
    <artifactId>mapstruct-jdk8</artifactId>
    <version>1.2.0.Final</version>
</dependency>
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>1.2.0.Final</version>
</dependency>

less复制代码@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CarPo {
    private Integer id;
    private String brand;
}

less复制代码@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CarVo {
    private Integer id;
    private String brand;
}

java复制代码@Mapper
public interface CarCovertBasic {
    CarCovertBasic INSTANCE = 
    Mappers.getMapper(CarCovertBasic.class);
    
    CarVo toConvertVo(CarPo source);
}

ini复制代码//实际中从数据库取
CarPo carPo = CarPo.builder().id(1)
                           .brand("BMW")
                           .build();
CarVo carVo = CarCovertBasic.INSTANCE.toConvertVo(carPo);
System.out.println(carVo);

ini复制代码CarVo(id=1, brand=BMW)

kotlin复制代码@Mapper
public interface CarCovertBasic {
CarCovertBasic INSTANCE = Mappers.getMapper(CarCovertBasic.class);

@Mapping(source = "carName", target = "name")
CarVo toConvertVo(CarPo source);
}

ini复制代码CarPo carPo = CarPo.builder().id(1)
                       .brand("BMW")
                       .carName("宝马")
                       .build();
CarVo carVo = CarCovertBasic.INSTANCE.toConvertVo(carPo);
System.out.println(carVo);

ini复制代码CarVo(id=1, brand=BMW, name=宝马)

ini复制代码@Mapper
public interface CarCovertBasic {
    CarCovertBasic INSTANCE = Mappers.getMapper(CarCovertBasic.class);

    @Mapping(source = "carName", target = "name")
    CarVo toConvertVo(CarPo source);

    List<CarVo> toConvertVos(List<CarPo> source);
}

less复制代码@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CarPo {
    private Integer id;
    private String brand;
    private String carName;
    private Date createTime;
}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CarVo {
    private Integer id;
    private String brand;
    private String name;
    private String createTime;
}

less复制代码@Mapper
public interface CarCovertBasic {
    CarCovertBasic INSTANCE = Mappers.getMapper(CarCovertBasic.class);
    @Mappings({
        @Mapping(source = "carName", target = "name"),
        @Mapping(target = "createTime", expression = "java(com.guduyan.util.DateUtil.dateToStr(source.getCreateTime()))")
    })
    CarVo toConvertVo(CarPo source);

    List<CarVo> toConvertVos(List<CarPo> source);
}

less复制代码@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AttributePo {
    private double price;
    private String color;
}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CarBo {
    private Integer id;
    private String brand;
    private String carName;
    private Date createTime;
    private double price;
    private String color;
}

less复制代码@Mapper
public interface CarCovertBasic {
    CarCovertBasic INSTANCE = Mappers.getMapper(CarCovertBasic.class);
    @Mappings({
        @Mapping(source = "carName", target = "name"),
        @Mapping(target = "createTime", expression = "java(com.guduyan.util.DateUtil.dateToStr(source.getCreateTime()))")
    })
    CarVo toConvertVo(CarPo source);

    List<CarVo> toConvertVos(List<CarPo> source);

    CarBo toConvertBo(CarPo source1, AttributePo source2);
}

python复制代码lowest = 2.5  # 网格最低价格
highest = 3.5  # 网格最高价格
parts = 20  # 网格数
start_value = 300.0  # 账户初始资金 
timespan = 15  # 每15秒检测一次标的价格
wechat_reminder = 1  # 是否通过微信通知（1：是，0：否）
mail_reminder = 0  # 是否通过邮件通知（1：是，0：否）
mail_list = ['mailbox1', ]  # 需要通知的邮箱列表

python复制代码# 每一格的高度
price_part_value = (highest - lowest) / parts
# 每变动一格对应的持仓百分比
percent_part_value = 1 / parts
# 所有网格的标记价格
price_levels = [round(highest - index * price_part_value, 4) for index in range(parts + 1)]
price_levels[-1] = lowest
# 每一格对应的整体持仓百分比
percent_levels = [round(0 + index * percent_part_value, 4) for index in range(parts + 1)]
percent_levels[-1] = 1.0000

python复制代码# 如果当前价格比网格最低价格高则按照网格计算建仓层数，反之直接全仓
# order_target_percent根据target的符号及数值判断买入还是卖出，并下单交易
if float(close) > price_levels[0]:
    pos = [close > level for level in price_levels]
    i = pos.index(False) - 1
    last_price_index = i
    target = percent_levels[last_price_index] - last_percent
    if target != 0.0:
        return True, order_target_percent(float(close), depth, target, date=date)
else:
    return True, order_target_percent(float(close), depth, 1.0, date=date)

python复制代码signal = False
while True:
    upper = None
    lower = None
    if last_price_index > 0:
        upper = price_levels[last_price_index - 1]
    if last_price_index < len(price_levels) - 1:
        lower = price_levels[last_price_index + 1]
    # 还不是最轻仓，继续涨，就再卖一档
    if upper and float(close) > upper:
        last_price_index = last_price_index - 1
        signal = True
        continue
    # 还不是最重仓，继续跌，再买一档
    if lower and float(close) < lower:
        last_price_index = last_price_index + 1
        signal = True
        continue
    break
if signal:
    target = percent_levels[last_price_index] - last_percent
    if target != 0.0:
        return True, order_target_percent(float(close), depth, target, date=date)
else:
    return False, []

python复制代码import asyncio
from typing import Optional, Union
from wechaty import Wechaty, Contact
from wechaty.user import Message, Room

async def wechat():
    bot = Wechaty()
    # 将on_message方法绑定到bot对象的message事件上
    bot.on('message', on_message)
    await bot.start()
    
async def on_message(msg: Message):
    from_contact = msg.talker()
    text = msg.text()
    room = msg.room()
    conversation: Union[
        Room, Contact] = from_contact if room is None else room
    await conversation.ready()
    await conversation.say('收到')
    
asyncio.run(wechat())

python复制代码async def on_message(msg: Message):
    from_contact = msg.talker()
    text = msg.text()
    room = msg.room()
    conversation: Union[
        Room, Contact] = from_contact if room is None else room
    if from_contact.payload.name.upper() == AdminWechatName and from_contact.contact_id.upper() == AdminWechatContactId:
        # 发送#GRIDSTATUS时回复当前网格仓位状态等
        if text.upper() == '#GRIDSTATUS':
            await conversation.ready()
            await conversation.say(str(grid))
        # 发送#SETGRID:格式信息时动态修改网格参数
        elif text.upper().startswith('#SETGRID:'):
            paras = {('grid.' + item.split('=')[0]): item.split('=')[1] for item in text[9:].lower().split(';')}
            cfg.set_paras(paras)
            await run_grid()

async def run_grid():
    flag, content = grid.run_data(data)
    if flag:
        if int(grid.mail_reminder):
        	for mail_box in grid.mail_list:
              	mail_helper.sendmail(mail_box, 'GRID SCRIPT NEW TRADE', content)
        if int(grid.wechat_reminder):
            await trade_reminder(bot, content)
            
async def trade_reminder(bot, mail_content, target=None):
    for id in target:
        room = bot.Room.load(id)
        await room.ready()
        conversation: Union[Room, Contact] = room
        await conversation.ready()
        await conversation.say(mail_content)

html复制代码https://github.com/TitusWongCN/

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

java复制代码/**
 * @author Ye Hongzhi 公众号：java技术爱好者
 * @name DemoController
 * @date 2020-08-25 22:28
 **/
@org.springframework.stereotype.Controller("/demo/controller")
public class DemoController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //业务处理
        return null;
    }
}

java复制代码/**
 * @author Ye Hongzhi 公众号：java技术爱好者
 * @name HttpDemoController
 * @date 2020-08-25 22:45
 **/
@Controller("/http/controller")
public class HttpDemoController implements HttpRequestHandler{
    @Override
    public void handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException {
        //业务处理
    }
}

java复制代码@Controller("/servlet/controller")
public class ServletDemoController implements Servlet {
    //以下是Servlet生命周期方法
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {
    }
}

java复制代码@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    @Bean
    public SimpleServletHandlerAdapter simpleServletHandlerAdapter() {
        return new SimpleServletHandlerAdapter();
    }
}

java复制代码@Controller
@RequestMapping("/requestMapping/controller")
public class RequestMappingController {

    @RequestMapping("/demo")
    public String demo() {
        return "HelloWord";
    }
}

java复制代码	@RequestMapping(value = "/restful", method = RequestMethod.GET)
    public String get() {
        //查询
        return "get";
    }

    @RequestMapping(value = "/restful", method = RequestMethod.POST)
    public String post() {
        //创建
        return "post";
    }

    @RequestMapping(value = "/restful", method = RequestMethod.PUT)
    public String put() {
        //更新
        return "put";
    }

    @RequestMapping(value = "/restful", method = RequestMethod.DELETE)
    public String del() {
        //删除
        return "post";
    }

java复制代码	//匹配 /antA 或者 /antB 等URL
    @RequestMapping("/ant?")
    public String ant() {
        return "ant";
    }

    //匹配 /ant/a/create 或者 /ant/b/create 等URL
    @RequestMapping("/ant/*/create")
    public String antCreate() {
        return "antCreate";
    }

    //匹配 /ant/create 或者 /ant/a/b/create 等URL
    @RequestMapping("/ant/**/create")
    public String antAllCreate() {
        return "antAllCreate";
    }

java复制代码@RequestMapping(value = "/restful", method = RequestMethod.POST)
public String post(Integer id, String name, int money) {
    System.out.println("id:" + id + ",name:" + name + ",money:" + money);
    return "post";
}

java复制代码	/**
     * value: 参数名
     * required: 是否request中必须包含此参数，默认是true。
     * defaultValue: 默认参数值
     */
    @RequestMapping(value = "/restful", method = RequestMethod.GET)
    public String get(@RequestParam(value = "userId", required = false, defaultValue = "0") String id) {
        System.out.println("id:" + id);
        return "get";
    }

java复制代码@RequestMapping(value = "/restful/{id}", method = RequestMethod.GET)
public String search(@PathVariable("id") String id) {
    System.out.println("id:" + id);
    return "search";
}

java复制代码	@RequestMapping("/head")
    public String head(@RequestHeader("Accept-Language") String acceptLanguage) {
        return acceptLanguage;
    }

java复制代码	@RequestMapping("/cookie")
    public String cookie(@CookieValue("_ga") String _ga) {
        return _ga;
    }

java复制代码public class User {
    private String id;
    private String name;
    private Integer age;
    //getter、setter方法
}

java复制代码	@RequestMapping("/body")
    public String body(User user) {
        return user.toString();
    }

java复制代码public class Address {
    private String id;
    private String name;
    //getter、setter方法
}

java复制代码public class User {
    private String id;
    private String name;
    private Integer age;
    private Address address;
    //getter、setter方法
}

java复制代码	//user和address都有id和name这两个属性	
	@RequestMapping(value = "/twoBody", method = RequestMethod.POST)
    public String twoBody(User user, Address address) {
        return user.toString() + "," + address.toString();
    }

java复制代码	@InitBinder("user")
    public void initBindUser(WebDataBinder webDataBinder) {
        webDataBinder.setFieldDefaultPrefix("u.");
    }

    @InitBinder("address")
    public void initBindAddress(WebDataBinder webDataBinder) {
        webDataBinder.setFieldDefaultPrefix("addr.");
    }

java复制代码	@RequestMapping(value = "/requestBody", method = RequestMethod.POST)
    public String requestBody(@RequestBody User user) {
        return user.toString();
    }

java复制代码public class StringToDateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            //String转换成Date类型
            return sdf.parse(source);
        } catch (Exception e) {
            //类型转换错误
            e.printStackTrace();
        }
        return null;
    }
}

java复制代码@Configuration
public class ConverterConfig extends WebMvcConfigurationSupport {
    @Override
    protected void addFormatters(FormatterRegistry registry) {
        //添加类型转换器
        registry.addConverter(new StringToDateConverter());
    }
}

xml复制代码<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <version>7.0.59</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

java复制代码@Configuration
public class WebAppConfig extends WebMvcConfigurerAdapter {
    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/");
        viewResolver.setSuffix(".jsp");
        viewResolver.setViewClass(JstlView.class);
        return viewResolver;
    }
}

java复制代码@Controller
@RequestMapping("/view")
public class ViewController {
    @RequestMapping("/hello")
    public String hello() throws Exception {
        return "hello";
    }
}

java复制代码//用在类、方法上
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseBody {
}

java复制代码@RequestMapping("/userList")
@ResponseBody
public List<User> userList() throws Exception {
    List<User> list = new ArrayList<>();
    list.add(new User("1","姚大秋",18));
    list.add(new User("2","李星星",18));
    list.add(new User("3","冬敏",18));
    return list;
}

java复制代码@Controller
@RequestMapping("/modelAttribute")
public class ModelAttributeController {
	//先执行这个方法
    @ModelAttribute
    public void modelAttribute(Model model){
        //在request域中放入数据
        model.addAttribute("userName","公众号：java技术爱好者");
    }

    @RequestMapping("/index")
    public String index(){
        //跳转到inex.jsp页面
        return "index";
    }
}

jsp复制代码<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
<!-- 获取到userName属性值 -->
<h1>${userName}</h1>
</body>
</html>

java复制代码//放在有参数的方法上
@ModelAttribute
public User userAttribute() {
    //相当于model.addAttribute("user",new User("1", "Java技术爱好者", 18));
    return new User("1", "Java技术爱好者", 18);
}

@RequestMapping("/user")
public String user() {
    return "user";
}

jsp复制代码<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
<h1>ID:${user.id}</h1>
<h1>名称:${user.name}</h1>
<h1>年龄:${user.age}岁</h1>
</body>
</html>

java复制代码//自定义属性名为"u"
@ModelAttribute("u")
public User userAttribute() {
    return new User("1", "Java技术爱好者", 18);
}
/**
JSP就要改成这样写：
<h1>ID:${u.id}</h1>
<h1>名称:${u.name}</h1>
<h1>年龄:${u.age}岁</h1>
*/

java复制代码@Controller
@RequestMapping("/modelAttribute")
public class ModelAttributeController {
    
    @RequestMapping("/jojo")
    @ModelAttribute("attributeName")
    public String jojo() {
        return "JOJO！我不做人了！";
    }
}

jsp复制代码<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
<h1>${attributeName}</h1>
</body>
</html>

java复制代码@ModelAttribute("u")
public User userAttribute() {
    return new User("1", "Java技术爱好者", 18);
}

@RequestMapping("/java")
public String user1(@ModelAttribute("u") User user) {
    //拿到@ModelAttribute("u")方法返回的值，打印出来
    System.out.println("user:" + user);
    return "java";
}

java复制代码public class DemoInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //预处理，返回true则继续执行。如果需要登录校验，校验不通过返回false即可，通过则返回true。
        System.out.println("执行preHandle()方法");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        //后处理
        System.out.println("执行postHandle()方法");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //在DispatcherServlet完全处理完请求后被调用
        System.out.println("执行afterCompletion()方法");
    }
}

java复制代码@Configuration
public class ConverterConfig extends WebMvcConfigurationSupport {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new DemoInterceptor()).addPathPatterns("/**");
    }
}

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <!-- 定义默认的异常处理页面 -->
        <property name="defaultErrorView" value="err"/>
        <!-- 定义异常处理页面用来获取异常信息的属性名，默认名为exception -->
        <property name="exceptionAttribute" value="ex"/>
        <!-- 定义需要特殊处理的异常，用类名或完全路径名作为key，异常也页名作为值 -->
        <property name="exceptionMappings">
            <props>
                <!-- 异常，err表示err.jsp页面 -->
                <prop key="java.lang.Exception">err</prop>
                <!-- 可配置多个prop -->
            </props>
        </property>
    </bean>
</beans>

java复制代码@SpringBootApplication
@ImportResource("classpath:spring-config.xml")
public class SpringmvcApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringmvcApplication.class, args);
    }

}

jsp复制代码<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>异常页面</title>
</head>
<body>
<h1>出现异常，这是一张500页面</h1>
<br>
<%-- 打印异常到页面上 --%>
<% Exception ex = (Exception)request.getAttribute("ex"); %>
<br>
<div><%=ex.getMessage()%></div>
<% ex.printStackTrace(new java.io.PrintWriter(out)); %>
</body>
</html>

java复制代码@Controller
@RequestMapping("/exception")
public class ExceptionController {
    @RequestMapping("/index")
    public String index(String msg) throws Exception {
        if ("null".equals(msg)) {
            //抛出空指针异常
            throw new NullPointerException();
        }
        return "index";
    }
}

java复制代码//HttpStatus枚举有所有的状态码，这里返回一个400的响应码
@ResponseStatus(value = HttpStatus.BAD_REQUEST)
public class DefinedException extends Exception{
}

java复制代码@RequestMapping("/defined")
public String defined(String msg) throws Exception {
    if ("defined".equals(msg)) {
        throw new DefinedException();
    }
    return "index";
}

java复制代码public class BaseException extends Exception {
    public BaseException(String message) {
        super(message);
    }
}

java复制代码public class ErrorInfo {
    public static final Integer OK = 0;
    public static final Integer ERROR = -1;
    private Integer code;
    private String message;
    private String url;
    //getter、setter
}

java复制代码//这里使用了RestControllerAdvice，是@ResponseBody和@ControllerAdvice的结合
//会把实体类转成JSON格式的提示返回，符合前后端分离的架构
@RestControllerAdvice
public class GlobalExceptionHandler {

    //这里自定义了一个BaseException，当抛出BaseException异常就会被此方法处理
    @ExceptionHandler(BaseException.class)
    public ErrorInfo errorHandler(HttpServletRequest req, BaseException e) throws Exception {
        ErrorInfo r = new ErrorInfo();
        r.setMessage(e.getMessage());
        r.setCode(ErrorInfo.ERROR);
        r.setUrl(req.getRequestURL().toString());
        return r;
    }
}

java复制代码@RequestMapping("/base")
public String base(String msg) throws Exception {
    if ("base".equals(msg)) {
        throw new BaseException("测试抛出BaseException异常，欧耶！");
    }
    return "index";
}

java复制代码  <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

java复制代码server:
  port: 9991
eureka:
  client:
    service-url:
      defaultZone: http://localhost:${server.port}/eureka/
    register-with-eureka: false 
    fetch-registry: false

java复制代码EnableEurekaServer // 该注解标识该服务是服务注册中心。
SpringBootApplication
public class MicroEureka {
    public static void main(String[] args) {
        SpringApplication.run(MicroEureka.class,args);
    }
}

java复制代码	<dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-openfeign</artifactId>
         </dependency>
            <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>

java复制代码Spring:
  application:
    name: cityclient
server:
  port: 8081
eureka:
  client:
    service-url:
      defaultZone: http://localhost:9991/eureka/

java复制代码SpringBootApplication
// 该服务是Eureka的客户端，仅限于Eureka
@EnableEurekaClient
// 注册中心有许多替代品，该注解无缝适应其他注册中心
@EnableDiscoveryClient
// 表明此服务要进行远程调用
@EnableFeignClients
public class MicroEurekaClient {
    public static void main(String[] args) {
        SpringApplication.run(MicroEurekaClient.class,args);
    }
}

java复制代码@FeignClient(value = "city") // 服务名
public interface CityClient {
	// 对应的url
    @GetMapping("cityTest")
     String select();
}

java复制代码   @Autowired
    private RestTemplate restTemplate;
    @GetMapping("testRibbon")
    public void  testRibbon(){
        String result = restTemplate.getForObject("http://city/cityTest", String.class);
        System.out.println(result);
    }

java复制代码// value 指定调用哪个服务
// fallback 指定由哪个类返回快速失败结果    
@FeignClient(value = "city", fallback = CityClientImpl.class) //
public interface CityClient {
	  // 客户端的地址
    @GetMapping("cityTest")
     String select();
}

java复制代码@Component
public class CityClientImpl implements CityClient {
    @Override
    public String select() {
        return "调用失败";
    }
}

java复制代码@Slf4j
class T extends Thread {
    @Override
    public void run() {
        log.info("我是继承Thread的任务");
    }
}
@Slf4j
class R implements Runnable {

    @Override
    public void run() {
        log.info("我是实现Runnable的任务");
    }
}
@Slf4j
class C implements Callable<String> {

    @Override
    public String call() throws Exception {
        log.info("我是实现Callable的任务");
        return "success";
    }
}

java复制代码// 启动继承Thread类的任务
new T().start();

// 启动继承Thread匿名内部类的任务 可用lambda优化
Thread t = new Thread(){
  @Override
  public void run() {
    log.info("我是Thread匿名内部类的任务");
  }
};

//  启动实现Runnable接口的任务
new Thread(new R()).start();

//  启动实现Runnable匿名实现类的任务
new Thread(new Runnable() {
    @Override
    public void run() {
        log.info("我是Runnable匿名内部类的任务");
    }
}).start();

//  启动实现Runnable的lambda简化后的任务
new Thread(() -> log.info("我是Runnable的lambda简化后的任务")).start();

// 启动实现了Callable接口的任务 结合FutureTask 可以获取线程执行的结果
FutureTask<String> target = new FutureTask<>(new C());
new Thread(target).start();
log.info(target.get());

java复制代码// 方法的定义
public static native void yield();

Runnable r1 = () -> {
    int count = 0;
    for (;;){
       log.info("---- 1>" + count++);
    }
};
Runnable r2 = () -> {
    int count = 0;
    for (;;){
        Thread.yield();
        log.info("            ---- 2>" + count++);
    }
};
Thread t1 = new Thread(r1,"t1");
Thread t2 = new Thread(r2,"t2");
t1.start();
t2.start();

// 运行结果
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129504
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129505
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129506
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129507
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129508
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129509
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129510
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129511
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129512
11:49:15.798 [t2] INFO thread.TestYield -             ---- 2>293
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129513
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129514
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129515
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129516
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129517
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129518

java复制代码 public final static int MIN_PRIORITY = 1;

 public final static int NORM_PRIORITY = 5;

 public final static int MAX_PRIORITY = 10;
 
 // 方法的定义
 public final void setPriority(int newPriority) {
 }

java复制代码Runnable r1 = () -> {
    int count = 0;
    for (;;){
       log.info("---- 1>" + count++);
    }
};
Runnable r2 = () -> {
    int count = 0;
    for (;;){
        log.info("            ---- 2>" + count++);
    }
};
Thread t1 = new Thread(r1,"t1");
Thread t2 = new Thread(r2,"t2");
t1.setPriority(Thread.NORM_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();

// 可能的运行结果
11:59:00.696 [t1] INFO thread.TestYieldPriority - ---- 1>44102
11:59:00.696 [t2] INFO thread.TestYieldPriority -             ---- 2>135903
11:59:00.696 [t2] INFO thread.TestYieldPriority -             ---- 2>135904
11:59:00.696 [t2] INFO thread.TestYieldPriority -             ---- 2>135905
11:59:00.696 [t2] INFO thread.TestYieldPriority -             ---- 2>135906

java复制代码Runnable r1 = () -> {
    int count = 0;
    for (int i = 0; i < 10; i++) {
        log.info("---- 1>" + count++);
    }
};
Runnable r2 = () -> {
    int count = 0;
    for (int i = 0; i < 10; i++) {
        log.info("            ---- 2>" + count++);

    }
};
Thread t1 = new Thread(r1,"t1");
Thread t2 = new Thread(r2,"t2");
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();

// 可能的运行结果 线程1优先级低 却先运行完
12:01:09.916 [t1] INFO thread.TestYieldPriority - ---- 1>7
12:01:09.916 [t1] INFO thread.TestYieldPriority - ---- 1>8
12:01:09.916 [t1] INFO thread.TestYieldPriority - ---- 1>9
12:01:09.916 [t2] INFO thread.TestYieldPriority -             ---- 2>2
12:01:09.916 [t2] INFO thread.TestYieldPriority -             ---- 2>3
12:01:09.916 [t2] INFO thread.TestYieldPriority -             ---- 2>4
12:01:09.916 [t2] INFO thread.TestYieldPriority -             ---- 2>5
12:01:09.916 [t2] INFO thread.TestYieldPriority -             ---- 2>6
12:01:09.916 [t2] INFO thread.TestYieldPriority -             ---- 2>7
12:01:09.916 [t2] INFO thread.TestYieldPriority -             ---- 2>8
12:01:09.916 [t2] INFO thread.TestYieldPriority -             ---- 2>9

java复制代码// 方法的定义
public final void setDaemon(boolean on) {
}

Thread thread = new Thread(() -> {
    while (true) {
    }
});
// 具体的api。设为true表示未守护线程，当主线程结束后，守护线程也结束。
// 默认是false，当主线程结束后，thread继续运行，程序不停止
thread.setDaemon(true);
thread.start();
log.info("结束");

java复制代码// 方法的定义 native方法
public static native void sleep(long millis) throws InterruptedException; 

try {
   // 休眠2秒
   // 该方法会抛出 InterruptedException异常 即休眠过程中可被中断，被中断后抛出异常
   Thread.sleep(2000);
 } catch (InterruptedException异常 e) {
 }
 try {
   // 使用TimeUnit的api可替代 Thread.sleep 
   TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 }

java复制代码// 方法的定义 有重载
// 等待线程执行完才恢复运行
public final void join() throws InterruptedException {
}
// 指定join的时间。指定时间内 线程还未执行完 调用方线程不继续等待就恢复运行
public final synchronized void join(long millis)
    throws InterruptedException{}

java复制代码Thread t = new Thread(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    r = 10;
});

t.start();
// 让主线程阻塞 等待t线程执行完才继续执行 
// 去除该行，执行结果为0，加上该行 执行结果为10
t.join();
log.info("r:{}", r);

// 运行结果
13:09:13.892 [main] INFO thread.TestJoin - r:10

java复制代码// 相关方法的定义
public void interrupt() {
}
public boolean isInterrupted() {
}
public static boolean interrupted() {
}

java复制代码@Slf4j
class TwoPhaseTerminal{
    // 监控线程
    private Thread monitor;

    public void start(){
        monitor = new Thread(() ->{
           // 不停的监控
            while (true){
                Thread thread = Thread.currentThread();
             	// 判断当前线程是否被打断
                if (thread.isInterrupted()){
                    log.info("当前线程被打断,结束运行");
                    break;
                }
                try {
                    Thread.sleep(1000);
                	// 监控逻辑中被打断后，打断标记为true
                    log.info("监控");
                } catch (InterruptedException e) {
                    // 睡眠时被打断时抛出异常 在该处捕获到 此时打断标记还是false
                    // 在调用一次中断 使得中断标记为true
                    thread.interrupt();
                }
            }
        });
        monitor.start();
    }

    public void stop(){
        monitor.interrupt();
    }
}

java复制代码public enum State {
	NEW,
	RUNNABLE,
	BLOCKED,
	WAITING,
	TIMED_WAITING,
	TERMINATED;
}

java复制代码// 对象的成员变量
private static int count = 0;

public static void main(String[] args) throws InterruptedException {
  // t1线程对变量+5000次
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            count++;
        }
    });
  // t2线程对变量-5000次
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            count--;
        }
    });

    t1.start();
    t2.start();

    // 让t1 t2都执行完
    t1.join();
    t2.join();
    System.out.println(count);
}

// 运行结果 
-1399

java复制代码// 加在方法上 实际是对this对象加锁
private synchronized void a() {
}

// 同步代码块,锁对象可以是任意的，加在this上 和a()方法作用相同
private void b(){
    synchronized (this){

    }
}

// 加在静态方法上 实际是对类对象加锁
private synchronized static void c() {

}

// 同步代码块 实际是对类对象加锁 和c()方法作用相同
private void d(){
    synchronized (TestSynchronized.class){
        
    }
}

// 上述b方法对应的字节码源码 其中monitorenter就是加锁的地方
 0 aload_0
 1 dup
 2 astore_1
 3 monitorenter
 4 aload_1
 5 monitorexit
 6 goto 14 (+8)
 9 astore_2
10 aload_1
11 monitorexit
12 aload_2
13 athrow
14 return

java复制代码private static int count = 0;

private static Object lock = new Object();

private static Object lock2 = new Object();

 // t1线程和t2对象都是对同一对象加锁。保证了线程安全。此段代码无论执行多少次，结果都是0
public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            synchronized (lock) {
                count++;
            }
        }
    });
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            synchronized (lock) {
                count--;
            }
        }
    });
 
    t1.start();
    t2.start();

    // 让t1 t2都执行完
    t1.join();
    t2.join();
    System.out.println(count);
}

java复制代码static final Object lock = new Object();
new Thread(() -> {
    synchronized (lock) {
        log.info("开始执行");
        try {
          	// 同步代码内部才能调用
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("继续执行核心逻辑");
    }
}, "t1").start();

new Thread(() -> {
    synchronized (lock) {
        log.info("开始执行");
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("继续执行核心逻辑");
    }
}, "t2").start();

try {
    Thread.sleep(2000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
log.info("开始唤醒");

synchronized (lock) {
  // 同步代码内部才能调用
    lock.notifyAll();
}
// 执行结果
14:29:47.138 [t1] INFO TestWaitNotify - 开始执行
14:29:47.141 [t2] INFO TestWaitNotify - 开始执行
14:29:49.136 [main] INFO TestWaitNotify - 开始唤醒
14:29:49.136 [t2] INFO TestWaitNotify - 继续执行核心逻辑
14:29:49.136 [t1] INFO TestWaitNotify - 继续执行核心逻辑

复制代码指的是有生产者来生产数据，消费者来消费数据，生产者生产满了就不生产了，通知消费者取，等消费了再进行生产。

java复制代码  public static void main(String[] args) throws InterruptedException {
        MessageQueue queue = new MessageQueue(2);
		
		// 三个生产者向队列里存值
        for (int i = 0; i < 3; i++) {
            int id = i;
            new Thread(() -> {
                queue.put(new Message(id, "值" + id));
            }, "生产者" + i).start();
        }

        Thread.sleep(1000);

		// 一个消费者不停的从队列里取值
        new Thread(() -> {
            while (true) {
                queue.take();
            }
        }, "消费者").start();

    }
}


// 消息队列被生产者和消费者持有
class MessageQueue {
    private LinkedList<Message> list = new LinkedList<>();

    // 容量
    private int capacity;

    public MessageQueue(int capacity) {
        this.capacity = capacity;
    }

    /**
     * 生产
     */
    public void put(Message message) {
        synchronized (list) {
            while (list.size() == capacity) {
                log.info("队列已满，生产者等待");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.addLast(message);
            log.info("生产消息:{}", message);
            // 生产后通知消费者
            list.notifyAll();
        }
    }

    public Message take() {
        synchronized (list) {
            while (list.isEmpty()) {
                log.info("队列已空，消费者等待");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Message message = list.removeFirst();
            log.info("消费消息:{}", message);
            // 消费后通知生产者
            list.notifyAll();
            return message;
        }
    }


}
 // 消息
class Message {

    private int id;

    private Object value;
}