java复制代码char val[] = value;

java复制代码public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
	//字符数组,存储字符串的值
	private final char value[];
	//字符串类型的hash值，默认是0；
	private int hash;
    //String类的序列化ID，通过ID来识别软件版本
    private static final long serialVersionUID = -6849794470754667710L;
    
    private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];
    
}

java复制代码/*
*StringBuffer:线程安全的带缓存的String，可变的字符串
*/
String str = "abc";	//创建了一个对象

String str1 = new String("def");//创建了两个对象

str1 = str1 + str;//创建了一个"abcdef"字符串对象，底层使用了StringBuffer的append();

java复制代码//String str = "abc";
char data[] = {'a','b','c'};
String str == new String(data);

java复制代码/*无参构造*/
//不能进行追加，删除等操作，只能进行覆盖操作
public String(){
	this.value = "".value;
}

//将参数的value和hash值都直接赋值给新创建的对象
public String (String original){
    this.value = original.value;
    this.hash = original.hash;
}

//截取字符串的子串,substring就是调用此构造函数
public String(char value[]/*截取字符串的字符数组*/, int offset/*开始的位置*/, int count/*截取的长度*/){
    if(offset < 0){
        throws new StringIndexOutOfBoundsException(offset);
    }
    if(count <= 0){
        //截取长度不能小于0
        if(count < 0){
            throws new StringIndexOutOfBoundsException(count);
        }
        //count == 0时就代表没有进行截取,返回传入的value值
        if(offset <= value.length){
            this.value = "".value;
            return;
        }
    }
    //如果offset超届抛出异常
    if(offset > value.length - count){
        throws new StringIndexOutOfBoundsException(offset+count);
    }
    //都没有问题的时候
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

java复制代码//String中的hashCode
//在String中进行重写
public int hashCode(){
	int h = hash;
	if(h == 0 && value.length > 0){
		char val[] = value;
		for(int i = 0; i < value.length; i ++){
			h = 31 * h + val[i];
		}
		hash = h;
	}
	return h;
}

//Object中的hashCode
//看不见具体的实现方法，它自动给你返回一个hash值
public native int hashCode();

java复制代码//Object中的equals
public boolean equals(Object obj){
    return (this == obj)	//比较内存值
}

//String中的equals
public boolean equals(Object anObject){
    if(this == anObject){
        return true;
    }
    //测试anObject是否是String的实例
    if(anObject instanceof String){
        //将anObject强制转换成String类
        String anotherString = (String)anObject;
        int n = value.length;
        //判断他们的长度是否相等
        if(n == anotherString.value.length){
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            //将他们的每一个元素进行对比
            while(n-- != 0){
                if(v1[i] != v2[i]){
                    //一旦有元素不同，就证明他们不是同一对象
                    return false;
                }
                i ++;
            }
            return true;
        }
    }
    return false;
}

java复制代码public char charAt(int index){
	if((index < 0) || (index >= value.length)){
		//索引位置超出界限，抛出异常
		throw new StringIndexOutOfBoudsException(index);
	}
	//返回索引位置的字符
	return value[index];
}

java复制代码public String substring(int beginIndex){
	if(beginIndex < 0){
        //超出界限异常
        throw new StringIndexOutOfBoudsException(beginIndex);
    }
    //剪切的长度
    int subLen = value.length - beginIndex;
    //剪切的长度不能超过字符串的长度
    if(subLen < 0){
        throws new StringIndexOutOfBoudsException(subLen);
    }
    //如果index从0开始就返回字符串全部，不然就新建一个字符串返回
    return (beginIndex == 0) ? this : new String(value,beginIndex,subLen);
}

java复制代码public int indexOf(int ch/*传入字符时自动转化为int*/){
	return indexOf(int ch, int fromIndex/*开始查找的位置*/);
}
//进行重载
public int indexOf(int ch, int fromIndex){
	final int max = value.length;
    if(fromIndex < 0){
        //如果输入错误的index那么让函数从头开始查找
        fromIndex = 0;
    } else if(fromIndex >= max){
        //选择范围超出了界限
        return -1;
    }
    //查找通用字符，在java中存储的值通常都是小于MIN的
    //MIN_SUPPLEMENTARY_CODE_POINT = 0x010000
    if(ch < Character.MIN_SUPPLEMENTARY_CODE_POINT){
        final char[] value = this.value;
        for(int i = fromIndex; i < max; i ++){
            //找到后返回下标
            if(value[i] == ch){
                return i;
            }
        }
        //没有找到
        return -1;
    } else {
        //查找的是补充字符，不是通用字符
        return indexOfSupplementary(ch, fromIndex);
    }
}

java复制代码public String replace(char oldChar, char newChar){
    //要进行替换的字符不能相同，相同的话就相当于没有替换
    if(oldChar != newChar){
        int len = value.length;
        int i = -1;//记录是否有需要替换的字符
        char[] val = value;//避免直接操作原字符串
        //遍历查看需要替换字符的位置
        while（++i < len){
            if(val[i] == oldChar){
                break;
            }
        }
        //进行替换
        if(i < len){
            //替换后的字符串
            char buf[] = new char[len];
            //在遇到第一个需要替换的字符前直接进行复制
            for(int j = 0; j < i; j ++){
                buf[j] = val[j];
            }
            while(i < len){
                char c = val[i];
                buf[i] = (c == oldChar) ? newChar : c;
                i ++;
            }
            //返回替换后的字符串对象
            return new String (buf, true);
        }
    }
    return this;
}

java复制代码public String trim(){
	int len = value.length;
    int st = 0;//字符串的开始位置
    char[] val = value;
    //找到可见字符的起始位置
    while((st < len) && (val[st] <= ' ')){
        //遇见不可见字符则起始位置向后加
        st ++;
    }
    //找到可见字符的结束位置
    while((st < len) && val[len - 1] <= ' '){
        //遇见不可见字符则结尾向前加
        len --;
    }
    //将字符串从st开始到len结束进行剪切
    return ((st > 0) || (len < value.length))/*最少有一个空格被解决*/ ? substring(st,len) : this/*没有空格被消除*/;
}

java复制代码public String[] split(String regex){
	return split(regex, 0);	//进行重载，从字符串头开始
}

public String[] split(String regex, int limit){
    char ch = 0;
    /*
    *regex为一个字符时，这个字符不能为正则的元字符，例如"^$.+\\?{}[]"等
    *regex是两个字符的时候并且第一个是'\'时，第二个不能时数字或字母
    */
    if(((regex.value.length == 1 &&
             ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1)/*regex为一个字符时，这个字符不能为正则的元字符*/ ||
             (regex.length() == 2 &&
              regex.charAt(0) == '\\' &&
              (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
              ((ch-'a')|('z'-ch)) < 0 &&
              ((ch-'A')|('Z'-ch)) < 0)) &&/*regex是两个字符的时候并且第一个是'\'时，第二个不能时数字或字母*/
            (ch < Character.MIN_HIGH_SURROGATE ||
             ch > Character.MAX_LOW_SURROGATE)){
        int off = 0;
        int next = 0;
        //匹配的次数，没有设置时默认查询到字符串结束
        boolean limited = limit > 0;
        //存放结果的数组
        ArrayList<String> list = new ArrayList<>();
        
        while((next = indexOf(ch, off)) != -1/*查询regex在String中的位置，确认String中有regex的存在，等于this.indexOf(ch, off)*/){
            if(!limited || list.size() < limit - 1){
                //没有进行次数初始化，或者当前数组的大小小于规定的次数
                //将不包含regex的子字符串放入数组中
                list.add(substring(off,next));
                //off直接到已经查到的regex位置加1，跳过现在的regex
                off = next + 1;
            } else {
                //现在数组的大小已经等于limit - 1，只需要进行最后一次操作
                list.add(substring(off, value.length));
                off = value.length;
                break;
            }
        }
        if(off == 0){
            //没有找到字符串中的regex
            return new String[]{this};
        }
        if(!limited || list.size() < limit){
            //传入的limit > 字符串中regex的次数，需要将剩余的部分添加到数组中
            list.add(substring(off, value.length));
        }
        //构造结果
        int resultSize = list.size();
        if(limit == 0){
            //没有传入参数或者传入的时0时，将list最后面的空数据删除掉
            while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {   
            	resultSize --;     
            }
        }
        //返回结果
        String result[] = new String[resultSize];
        return list.subList(0, resultSize).toArray(result);
    }
    return Pattern.compile(regex).split(this, limit);
}

java复制代码"boo:foo:boo".split("0",0)
-----------result--------------
{"b","",":f","",":b",""}

sql复制代码CREATE TABLE table_name ( id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY, author VARCHAR(200), 
title VARCHAR(200), content TEXT(500), FULLTEXT full_index_name (col_name) ) ENGINE=InnoDB;

sql复制代码SELECT table_id, name, space from INFORMATION_SCHEMA.INNODB_TABLES
WHERE name LIKE 'test/%';

sql复制代码CREATE FULLTEXT INDEX full_index_name ON table_name(col_name);

sql复制代码MATCH(col1,col2,...) AGAINST(expr[search_modifier])
search_modifier:
{
    IN NATURAL LANGUAGE MODE
    | IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION
    | IN BOOLEAN MODE
    | WITH QUERY EXPANSION
}

sql复制代码SELECT
    count(*) AS count 
FROM
    `fts_articles` 
WHERE
    MATCH ( title, body ) AGAINST ( 'MySQL' );

sql复制代码SELECT
    count(IF(MATCH ( title, body ) 
    against ( 'MySQL' ), 1, NULL )) AS count 
FROM
    `fts_articles`;

sql复制代码SELECT
    *,
    MATCH ( title, body ) against ( 'MySQL' ) AS Relevance 
FROM
    fts_articles;

sql复制代码SELECT
    *,
    MATCH ( title, body ) against ( 'for' ) AS Relevance 
FROM
    fts_articles;

sql复制代码select * from fts_test where MATCH(content) AGAINST('+Pease -hot' IN BOOLEAN MODE);

sql复制代码SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH ( title, body ) AGAINST ( '+MySQL -YourSQL' IN BOOLEAN MODE );

sql复制代码SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH ( title, body ) AGAINST ( 'MySQL IBM' IN BOOLEAN MODE );

sql复制代码SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH ( title, body ) AGAINST ( '"DB2 IBM"@3' IN BOOLEAN MODE );

sql复制代码SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH ( title, body ) AGAINST ( '+MySQL +(>database <DBMS)' IN BOOLEAN MODE );

sql复制代码SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH ( title, body ) AGAINST ( 'MySQL ~database' IN BOOLEAN MODE );

sql复制代码SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH ( title, body ) AGAINST ( 'My*' IN BOOLEAN MODE );

sql复制代码SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH ( title, body ) AGAINST ( '"MySQL Security"' IN BOOLEAN MODE );

sql复制代码-- 创建索引
create FULLTEXT INDEX title_body_index on fts_articles(title,body);

sql复制代码-- 使用 Natural Language 模式查询
SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH(title,body) AGAINST('database');

sql复制代码-- 当使用 Query Expansion 模式查询
SELECT
    * 
FROM
    `fts_articles` 
WHERE
    MATCH(title,body) AGAINST('database' WITH QUERY expansion);

sql复制代码DROP INDEX full_idx_name ON db_name.table_name;

sql复制代码ALTER TABLE db_name.table_name DROP INDEX full_idx_name;

yaml复制代码##多数据源的配置
dynamic:
  datasource:
    slave1:
      driver-class-name: org.postgresql.Driver
      url: jdbc:postgresql://localhost:3306/yydsCarBase
      username: root
      password: 123456
    slave2:
      driver-class-name: org.postgresql.Driver
      url: jdbc:postgresql://localhost:3306/yydsCar1
      username: root
      password: 123456

java复制代码import java.lang.annotation.*;

/**
 * 多数据源注解
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource {
    String value() default "";
}

typescript复制代码
/**
 * 配置多数据源
 */
@Configuration
@EnableConfigurationProperties(DynamicDataSourceProperties.class)
public class DynamicDataSourceConfig {
    @Autowired
    private DynamicDataSourceProperties properties;
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }
    @Bean
    public DynamicDataSource dynamicDataSource(DataSourceProperties dataSourceProperties) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(getDynamicDataSource());
        //配置默认的数据源，无论有几个数据源，都要配置一个默认的， 不然跑不起来
        DruidDataSource defaultDataSource = DynamicDataSourceFactory.buildDruidDataSource(dataSourceProperties);
        dynamicDataSource.setDefaultTargetDataSource(defaultDataSource);
        return dynamicDataSource;
    }
    /**
     * 多数据源的其他数据源配置汇总 
     * 基本都是map<key,value>  <数据源名可以按租户名配置,数据库链接信息>
     * @return
     */
    private Map<Object, Object> getDynamicDataSource(){
        Map<String, DataSourceProperties> dataSourcePropertiesMap = properties.getDatasource();
        Map<Object, Object> targetDataSources = new HashMap<>(dataSourcePropertiesMap.size());
        dataSourcePropertiesMap.forEach((k, v) -> {
            DruidDataSource druidDataSource = DynamicDataSourceFactory.buildDruidDataSource(v);
            targetDataSources.put(k, druidDataSource);
        });
        return targetDataSources;
    }
}

/**
 * 多数据源
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicContextHolder.peek();
    }

}

scss复制代码public class DynamicDataSourceFactory {

    /**
     * 创建数据库链接的基本配置，这里如果是不同类型的数据库，需要留意下，比如Oracle、sqlservice啥的
     * @param properties
     * @return
     */
    public static DruidDataSource buildDruidDataSource(DataSourceProperties properties) {
        DruidDataSource druid = new DruidDataSource();
        try {
            druid.setDriverClassName(properties.getDriverClassName());
            druid.setUrl(properties.getUrl());
            druid.setUsername(properties.getUsername());
            druid.setPassword(properties.getPassword());
            druid.setInitialSize(properties.getInitialSize());
            druid.setMaxActive(properties.getMaxActive());
            druid.setMinIdle(properties.getMinIdle());
            druid.setMaxWait(properties.getMaxWait());
            druid.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRunsMillis());
            druid.setMinEvictableIdleTimeMillis(properties.getMinEvictableIdleTimeMillis());
            druid.setMaxEvictableIdleTimeMillis(properties.getMaxEvictableIdleTimeMillis());
            druid.setValidationQuery(properties.getValidationQuery());
            druid.setValidationQueryTimeout(properties.getValidationQueryTimeout());
            druid.setTestOnBorrow(properties.isTestOnBorrow());
            druid.setTestOnReturn(properties.isTestOnReturn());
            druid.setPoolPreparedStatements(properties.isPoolPreparedStatements());
            druid.setMaxOpenPreparedStatements(properties.getMaxOpenPreparedStatements());
            druid.setSharePreparedStatements(properties.isSharePreparedStatements());
            druidDataSource.setFilters(properties.getFilters());
            druidDataSource.init();
        } catch (SQLException e) {
            //其实这里还是有点问题，如果捕获异常了，还是返回数据库链接，外头还是链接不上的，Mark下
            e.printStackTrace();
        }
        return druidDataSource;
    }
}

typescript复制代码public class DynamicContextHolder {
    private static final ThreadLocal<Deque<String>> CONTEXT_HOLDER = new ThreadLocal() {
        @Override
        protected Object initialValue() {
            return new ArrayDeque();
        }
    };
    /**
     * 获得当前线程数据源
     * @return 数据源名称
     */
    public static String peek() {
        return CONTEXT_HOLDER.get().peek();
    }
    /**
     * 设置当前线程数据源
     * @param dataSource 数据源名称
     */
    public static void push(String dataSource) {
        CONTEXT_HOLDER.get().push(dataSource);
    }
    /**
     * 清空当前线程数据源
     */
    public static void poll() {
        Deque<String> deque = CONTEXT_HOLDER.get();
        deque.poll();
        if (deque.isEmpty()) {
            CONTEXT_HOLDER.remove();
        }
    }
}

less复制代码/**
 * 多数据源，切面处理类
 */
@Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class DataSourceAspect {

    @Pointcut("@annotation(io.renren.commons.dynamic.datasource.annotation.DataSource) " +
            "|| @within(io.renren.commons.dynamic.datasource.annotation.DataSource)")
    public void dataSourcePointCut() {
    }

    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Class targetClass = point.getTarget().getClass();
        Method method = signature.getMethod();
        DataSource targetDataSource = (DataSource)targetClass.getAnnotation(DataSource.class);
        DataSource methodDataSource = method.getAnnotation(DataSource.class);
        if(targetDataSource != null || methodDataSource != null){
            String value;
            if(methodDataSource != null){
                value = methodDataSource.value();
            }else {
                value = targetDataSource.value();
            }
            DynamicContextHolder.push(value);
        }
        try {
            return point.proceed();
        } finally {
            DynamicContextHolder.poll();
        }
    }
}

markdown复制代码1.Request对象
Request对象是javax.servlet.http.HttpServletRequest类的实例。代表请求对象，主要用于接受客户端通过HTTP协议连接传输到服务器端的数据。比如表单中的数据、网页地址后带的参数等。
2.Response对象
Response对象是javax.servlet.http.HttpServletResponse类的实例。代表响应对象，主要用于向客户端发送数据。
3.Out对象
Out对象是javax.servlet.jsp.JspWriter类的实例。主要用于向客户端浏览器输出数据。
4.session对象
Session 对象是javax.servlet.http.HttpSession类的实例。主要用来保持在服务器与一个客户端之间需要保留的数据，比如在会话期间保持用户的登录信息等，会话状态维持是Web应用开发者必须面对的问题。当客户端关闭网站的所有网页或关闭浏览器时，session对象中保存的数据会自动清除。由于Htp协议是一个无状态协议，不保留会话间的数据，因此通过session对象扩展了htp的功能。比如用户登录一个网站之后，登录信息会暂时保存在session对象中，打开不同的页面时，登录信息是可以共享的，一旦用户关闭浏览器或退出登录，就会清除session对象中保存的登录信息。
5.Application对象
Application对象是javax.servlet.ServletContext类的实例。主要用于保存用户信息，代码片段的运行环境；它是一个共享的内置对象，即一个容器中的多个用户共享一个application对象，故其保存的信息被所有用户所共享。
6.PageContext对象
PageContext对象是javax.servlet.jsp.PageContext类的实例。用来管理网页属性，为JSP页面包装页面的上下文，管理对属于JSP中特殊可见部分中已命名对象的访问，它的创建和初始化都是由JSP容器来完成的。
7.Config对象
Config对象是javax.servlet.ServletConfig类的实例。是代码片段配置对象，表示Servlet的配置。
8.Page（相当于this）对象
Page对象是javax.servlet.jsp.HttpJspPage类的实例。用来处理JSP网页，它指的是JSP页面对象本身，或者说代表编译后的servlet对象，只有在JSP页面范围之内才是合法的。
9.Exception对象
Exception对象是java.lang.Throwable类的实例。处理JSP文件执行时发生的错误和异常只有在JSP页面的page指令中指定isErrorPage=“true”后，才可以在本页面使用exception对象。

java复制代码@WebServlet("/CookieTest")
public class CookieTest extends HttpServlet {
	private static final long serialVersionUID = 1L;
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		request.setCharacterEncoding("utf-8");
		response.setContentType("text/html;charset=utf-8");
		Cookie[] cookies = request.getCookies();
		
		PrintWriter out = response.getWriter();
		
		if(cookies!=null){
			out.println("上次访问的时间是：");
			for (Cookie cookie : cookies) {
				if("lastTime".equals(cookie.getName())){
					long lastTime = Long.parseLong(cookie.getValue());
					Date date = new Date(lastTime);
					out.println(date.toLocaleString());
				}
			}
		}else{
			out.println("你是第一来");
		}
		
		Cookie cookie = new Cookie("lastTime", String.valueOf(System.currentTimeMillis()));
		//给cookie设置一些信息
		//cookie.setMaxAge(500); //有效期
		//cookie.setPath(uri);
		//服务器端给客户端一个Cookie
		response.addCookie(cookie);
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}
}

java复制代码//传中文，避免乱码。可以进行编码
Cookie cookie = new Cookie("lastTime",URLEncoder.encode("尚", "utf-8"));
//取出Cookie值，需要解码
URLDecoder.decode(cookie.getValue(),"utf-8");

java复制代码@WebServlet("/SessionTest1")
public class SessionTest extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		request.setCharacterEncoding("utf-8");
		response.setContentType("text/html;charset=utf-8");
		PrintWriter out = response.getWriter();
		out.write("Session的ID为：");
		// 获取 Session 
		HttpSession session = request.getSession();
		out.write(session.getId());
		session.setAttribute("name", "shang");
		//设置当前会话多久结束，单位秒。如果设置的值为零或负数，则表示会话将永远不会超时。常用于设置当前会话时间。
//		session.setMaxInactiveInterval(1);
	}
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}
}

java复制代码@WebServlet("/SessionTest2")
public class SessionTest2 extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		request.setCharacterEncoding("utf-8");
		response.setContentType("text/html;charset=utf-8");
		
		HttpSession session = request.getSession();
		//移除session的数据
		session.removeAttribute("name");
		//手动注销当前会话
		session.invalidate();
	}
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}
}

html复制代码  <%--
  ${pageContext.request.contextPath}：保证我发布在项目在服务器上也能被访问
  --%>

  <form action="${pageContext.request.contextPath}/upload.do" method="post" enctype="multipart/form-data">
    上传用户：<input type="text" name="username"><br/>
    <input type="file" name="file1"><br/>
    <input type="submit" value="提交"> | <input type="reset" value="重置">
  </form>

java复制代码package com.shang.servlet;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.ProgressListener;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.List;
import java.util.UUID;

public class FileServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //判断上传的表单是普通表单还是带文件的表单
        if(!ServletFileUpload.isMultipartContent(request)){
            return;
        }
        //创建上传文件的保存路径，建议在WEB-INF路径下，安全，用户无法直接访问上传的文件
        String uploadPath = this.getServletContext().getRealPath("/WEB-INF/upload");
        File uploadFile = new File(uploadPath);
        if(!uploadFile.exists()){
            uploadFile.mkdir();
        }

        //缓存，临时文件
        //临时路径，假如文件超出了预期的大小，我们就把他放到一个临时文件中，过几天自动删除，或者提醒用户转存为永久
        String tmpPath = this.getServletContext().getRealPath("/WEB-INF/tmp");
        File tmpFile = new File(tmpPath);
        if(!tmpFile.exists()){
            tmpFile.mkdir();
        }

        //处理上传的文件，一般都需要通过流来获取，我们可以使用request.getInputStream()，原生态的文件上传流获取，十分麻烦。但是我们都建议使用Apache的文件上传组件来实现，common-fileupload，它需要依赖于commons-io组件：
        //1. 创建DiskFileItemFactory对象，处理文件上传路径或者大小限制的
        DiskFileItemFactory factory = getDiskFileItemFactory(tmpFile);
        //2.获取ServletFileUpload
        ServletFileUpload upload = getServletFileUpload(factory);
        //3.处理上传的文件
        String msg = null;
        try {
            msg = uploadParseRequest(upload, request, response, uploadPath);
        } catch (FileUploadException e) {
            e.printStackTrace();
        }
        //servlet请求转发消息
        request.setAttribute("msg", msg);
        request.getRequestDispatcher("info.jsp").forward(request, response);

    }

    protected void doGet( HttpServletRequest request,  HttpServletResponse response) throws  ServletException, IOException {  
 }

    public  static DiskFileItemFactory getDiskFileItemFactory(File file){
        //通过这个工厂设置一个缓冲区，当上传的文件大于这个缓冲区的时候，将他放到临时文件中
        DiskFileItemFactory factory = new DiskFileItemFactory();
        factory.setSizeThreshold(1024 * 1024);//缓冲区大小为1M
        factory.setRepository(file);//临时目录的保存目录，需要一个File
        return factory;
    }

    public static ServletFileUpload getServletFileUpload(DiskFileItemFactory factory){
        ServletFileUpload upload = new ServletFileUpload(factory);
        //监听文件上传进度
        upload.setProgressListener(new ProgressListener() {
            @Override
            //pBytesRead：已经读取到的文件大小
            //pContentLength：文件大小
            public void update(long pBytesRead, long pContentLength, int pItems) {
                System.out.println("总大小："+pContentLength+"已上传："+pBytesRead);
            }
        });
        //处理乱码问题
        upload.setHeaderEncoding("UTF-8");
        //设置单个文件的最大值
        upload.setFileSizeMax(1024 * 1024 * 10);
        //设置总共能够上传文件的大小
        //1024 = 1kb * 1024 =1M * 10 =10M
        upload.setSizeMax(1024 * 1024 * 10);
        return upload;
    }

    public static String uploadParseRequest(ServletFileUpload upload,HttpServletRequest request,HttpServletResponse response,String uploadPath) throws FileUploadException, IOException {
        String msg = "";

        //把前端请求解析，封装成一个FileItem对象
        List<FileItem> fileItems = upload.parseRequest(request);
        for (FileItem fileItem : fileItems) {
            if(fileItem.isFormField()){ //判断上传文件是普通表单还是带文件的表单
                //getFiledName指的是前端表单控件的name
                String name = fileItem.getFieldName();
                String value = fileItem.getString("UTF-8"); //处理乱码
                System.out.println(name+":"+value);
            }else {//判断它是上传文件
                //========处理文件======
                String uploadFileName = fileItem.getName();
                System.out.println("上传的文件名："+uploadFileName);

                if(uploadFileName.trim().equals("")||uploadFileName==null){
                    continue;
                }
                //获取上传的文件名 /images/boy/cool.jpg
                String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/") + 1);
                //获取文件的后缀
                String fileExtName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1);
                /*
                *  如果文件后缀名 fileExtName 不是我们所需要的，
                *  就直接return，不处理，告诉用户文件类型不对
                * */
                System.out.println("文件信息 [件名："+fileName+"----文件类型"+fileExtName+"]");

                //可以使用UUID（唯一识别的通用码），保证文件的唯一
                //，UUID.randomUUID()，随机生成一个唯一识别的通用码
                String uuidPath = UUID.randomUUID().toString();

                //===========================处理文件完毕========
                //存到哪？ uploadPath
                //文件真实存在的路径 realPath
                String realPath = uploadPath +"/"+uuidPath;
                //给每个文件创建一个对应的文件夹
                File realPathFile = new File(realPath);
                if(!realPathFile.exists()){
                    realPathFile.mkdir();
                }

                //存放地址完毕

                //=======文件传输=====
                //获取文件的上传流
                InputStream inputStream = fileItem.getInputStream();
                //创建文件输出流
                //realPath 真实的文件夹
                //差一个文件；加上输出的名字+"/"+uuidFileName
                FileOutputStream fos = new FileOutputStream(realPath + "/" + fileName);

                //判断是否读取完毕
                int len = 0;
                //创建一个缓冲区
                byte[] buffer = new byte[1024*1024];
                //如果不等于-1说明还存在数据
                while((len = buffer.length)!= -1){
                    fos.write(buffer, 0, len);
                }

                //关闭流
                fos.close();
                inputStream.close();
                msg = "文件上传成功！";
                fileItem.delete();// 上传成功，清除临时文件
            }
        }
        return msg;
    }
}

java复制代码public class HelloServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取下载文件的路径
        //String path = this.getServletContext().getRealPath("/1.jpg");
        String path = "G:\\MyIDEProject\\JavaWeb\\UploadFile\\resources\\1.jpg";
        System.out.println("要下载的文件路径"+path);
        //2.下载的文件名
        String filename = path.substring(path.lastIndexOf("\\") + 1);
        //3.设置让浏览器支持我们要下载的东西
        response.setHeader("Content-Disposition", "attachment;filename="+filename);
        //4.获取下载文件的输入流
        File file = new File(path);
        FileInputStream fis = new FileInputStream(file);
        //5.创建缓冲区
        byte[] buffer = new byte[1024];
        int len = 0;
        //6.获取OutputStream对象
        ServletOutputStream fos = response.getOutputStream();
        //7.将FileOutputStream流写入到buffer缓冲区
        while((len = buffer.length)!=-1){
            //8.使用OutputStream将缓冲区中的数据输入到客户端
            fos.write(buffer, 0, len);
        }
        //9. 关闭流
        fos.close();
        fis.close();
    }
}

yaml复制代码# 集群节点1的配置信息
# 集群名称，节点之间要保持一致
cluster.name: elasticsearch
# 节点名称，集群内要唯一
node.name: node-9200
# 集群master
node.master: true
# 数据节点
node.data: true
 
# ip地址
network.host: localhost
# http端口
http.port: 9200
# tcp监听端口
transport.tcp.port: 9300

# 新节点用于加入集群的主节点列表，注意端口号是tcp端口，多个master节点时指定
#discovery.seed_hosts: ["localhost:9300", "localhost:9301","localhost:9302"]
#discovery.zen.fd.ping_timeout: 1m
#discovery.zen.fd.ping_retries: 5
 
# 集群内的可以被选为主节点的节点名称列表，需要是node.master
#cluster.initial_master_nodes: ["node-9200", "node-9201","node-9202"]
 
#跨域配置
#action.destructive_requires_name: true
http.cors.enabled: true
http.cors.allow-origin: "*"

yaml复制代码# 集群节点2的配置信息
# 集群名称，节点之间要保持一致
cluster.name: elasticsearch
# 节点名称，集群内要唯一
node.name: node-9201
# 集群master
node.master: false
# 数据节点
node.data: true
 
# ip地址
network.host: localhost
# http端口
http.port: 9201
# tcp监听端口
transport.tcp.port: 9301

# 新节点用于加入集群的主节点列表
discovery.seed_hosts: ["localhost:9300"]
discovery.zen.fd.ping_timeout: 1m
discovery.zen.fd.ping_retries: 5
 
# 集群内的可以被选为主节点的节点名称列表，需要是node.master
#cluster.initial_master_nodes: ["node-9200", "node-9201","node-9202"]
 
#跨域配置
#action.destructive_requires_name: true
http.cors.enabled: true
http.cors.allow-origin: "*"

yaml复制代码# 集群节点3的配置信息
# 集群名称，节点之间要保持一致
cluster.name: elasticsearch
# 节点名称，集群内要唯一
node.name: node-9202
# 集群master
node.master: true
# 数据节点
node.data: true
 
# ip地址
network.host: localhost
# http端口
http.port: 9202
# tcp监听端口
transport.tcp.port: 9302

# 新节点用于加入集群的主节点列表，注意端口号是tcp端口，多个master节点时指定
discovery.seed_hosts: ["localhost:9300"]
discovery.zen.fd.ping_timeout: 1m
discovery.zen.fd.ping_retries: 5
 
# 集群内的可以被选为主节点的节点名称列表，需要是node.master
#cluster.initial_master_nodes: ["node-9200", "node-9201","node-9202"]
 
#跨域配置
#action.destructive_requires_name: true
http.cors.enabled: true
http.cors.allow-origin: "*"

json复制代码{
  "cluster_name" : "elasticsearch",
  "status" : "green",
  "timed_out" : false,
  "number_of_nodes" : 3,
  "number_of_data_nodes" : 3,
  "active_primary_shards" : 7,
  "active_shards" : 14,
  "relocating_shards" : 0,
  "initializing_shards" : 0,
  "unassigned_shards" : 0,
  "delayed_unassigned_shards" : 0,
  "number_of_pending_tasks" : 0,
  "number_of_in_flight_fetch" : 0,
  "task_max_waiting_in_queue_millis" : 0,
  "active_shards_percent_as_number" : 100.0
}

json复制代码PUT cluster/_doc/1
{
	"name": "集群测试",
	"message": "主节点写入"
}

json复制代码{
	"took": 25,
	"timed_out": false,
	"_shards": {
		"total": 1,
		"successful": 1,
		"skipped": 0,
		"failed": 0
	},
	"hits": {
		"total": {
			"value": 1,
			"relation": "eq"
		},
		"max_score": 1,
		"hits": [
			{
				"_index": "cluster",
				"_type": "_doc",
				"_id": "1",
				"_score": 1,
				"_source": {
					"name": "集群测试",
					"message": "主节点写入"
				}
			}
		]
	}
}

yaml复制代码# 集群名称
cluster.name: cluster-es
# 节点名称，每个节点的名称不能重复
node.name: node-1
# ip地址，每个节点的地址不能重复
network.host: linux1
# 主节点
node.master: true
node.data: true
http.port: 9200
# 跨域配置
http.cors.allow-origin: "*"
http.cors.enabled: true
http.max_content_length: 200mb
# es7.x 之后新增的配置，初始化一个新的集群时需要此配置来选举master
cluster.initial_master_nodes: ["node-1"]
# es7.x 之后新增的配置，节点发现
discovery.seed_hosts: ["linux1:9300","linux2:9300","linux3:9300"]
gateway.recover_after_nodes: 2
network.tcp.keep_alive: true
network.tcp.no_delay: true
transport.tcp.compress: true
# 集群内同时启动的数据任务个数，默认是2个
cluster.routing.allocation.cluster_concurrent_rebalance: 16
# 添加或删除节点及负载均衡时并发恢复的线程个数，默认4个
cluster.routing.allocation.node_concurrent_recoveries: 16
# 初始化数据恢复时，并发恢复线程的个数，默认4个
cluster.routing.allocation.node_initial_primaries_recoveries: 16

json复制代码GET _analyze
{
  "analyzer": "standard",
  "text": ["中国人ABC"]
}

json复制代码{
  "tokens" : [
    {
      "token" : "中",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<IDEOGRAPHIC>",
      "position" : 0
    },
    {
      "token" : "国",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "<IDEOGRAPHIC>",
      "position" : 1
    },
    {
      "token" : "人",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "<IDEOGRAPHIC>",
      "position" : 2
    },
    {
      "token" : "abc",
      "start_offset" : 3,
      "end_offset" : 6,
      "type" : "<ALPHANUM>",
      "position" : 3
    }
  ]
}

json复制代码GET _analyze
{
  "analyzer": "keyword",
  "text": ["中国人ABC"]
}

json复制代码{
  "tokens" : [
    {
      "token" : "中国人ABC",
      "start_offset" : 0,
      "end_offset" : 6,
      "type" : "word",
      "position" : 0
    }
  ]
}

json复制代码GET _analyze 
{
  "analyzer": "分词器类型",
  "text": "我是中国人码坐标"
}

json复制代码GET _analyze 
{
  "analyzer": "ik_max_word",
  "text": "我是中国人码坐标"
}

json复制代码{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "中国人",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "码",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "CN_CHAR",
      "position" : 3
    },
    {
      "token" : "坐标",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 4
    }
  ]
}

json复制代码GET _analyze 
{
  "analyzer": "ik_max_word",
  "text": "我是中国人码坐标"
}

json复制代码{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "中国人",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "中国",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 3
    },
    {
      "token" : "国人",
      "start_offset" : 3,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 4
    },
    {
      "token" : "码",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "CN_CHAR",
      "position" : 5
    },
    {
      "token" : "坐标",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 6
    }
  ]
}

json复制代码{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "中国人",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "码坐标",
      "start_offset" : 5,
      "end_offset" : 8,
      "type" : "CN_CHAR",
      "position" : 3
    },
    {
      "token" : "坐标",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 4
    }
  ]
}

json复制代码PUT index
{
	"mappings": {
		"properties": {
			"content": {
				"type": "text",
				"analyzer": "ik_max_word",
				"search_analyzer": "ik_smart"
			}
		}
	}
}

json复制代码POST index/_doc/1
{
	"content": "美国留给伊拉克的是个烂摊子吗"
}

POST index/_doc/2
{
	"content": "公安部：各地校车将享最高路权"
}

POST index/_doc/3
{
	"content": "中韩渔警冲突调查：韩警平均每天扣1艘中国渔船"
}

POST index/_doc/4
{
	"content": "中国驻洛杉矶领事馆遭亚裔男子枪击 嫌犯已自首"
}

json复制代码GET index/_search
{
  "query": {
    "match": {
      "content": "中国"
    }
  },
  "highlight" : {
        "pre_tags" : ["<tag1>", "<tag2>"],
        "post_tags" : ["</tag1>", "</tag2>"],
        "fields" : {
            "content" : {}
        }
    }
}

json复制代码{
  "took" : 50,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 0.642793,
    "hits" : [
      {
        "_index" : "index",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.642793,
        "_source" : {
          "content" : "中韩渔警冲突调查：韩警平均每天扣1艘中国渔船"
        },
        "highlight" : {
          "content" : [
            "中韩渔警冲突调查：韩警平均每天扣1艘<tag1>中国</tag1>渔船"
          ]
        }
      },
      {
        "_index" : "index",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 0.642793,
        "_source" : {
          "content" : "中国驻洛杉矶领事馆遭亚裔男子枪击 嫌犯已自首"
        },
        "highlight" : {
          "content" : [
            "<tag1>中国</tag1>驻洛杉矶领事馆遭亚裔男子枪击 嫌犯已自首"
          ]
        }
      }
    ]
  }
}

CREATE复制代码	 id int not null AUTO_INCREMENT,
     user_id varchar(32) not null comment '发红包用户',
     money decimal(10,2) not null comment '红包金额',
     unit_money decimal(10,2) not null comment '单个红包金额',
     total int not null comment '红包个数',
     remain int not null comment '红包剩余个数',
     send_date datetime not null comment '发红包时间',
     primary key(id)
);
INSERT INTO send_redpack(user_id,money, unit_money,total,remain,send_date)
VALUES("001",10000.00,10.00,1000,1000,now());
	
CREATE TABLE get_redpack(
	id int not null AUTO_INCREMENT,
	user_id varchar(32) not null comment '抢红包用户',
	send_redpack_id int not null comment '发红包记录id',
	money decimal(10,2) not null comment '抢的红包金额',
	get_date datetime not null comment '抢红包时间',
	primary key(id)
);

>复制代码        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
 
 
 
# ----- RabbitMq -------- #
spring.rabbitmq.virtual-host=/
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin

arduino复制代码/**
 * 抢红包
 *
 * @author keying
 * @date 2021/6/22
 */
@Data
public class GetRedpack {
    /**
     *
     */
    private Integer id;
 
    /**
     * 抢红包用户
     */
    private String userId;
 
    /**
     * 发红包用户
     */
    private String sendRedpackId;
 
    /**
     * 抢的红包金额
     */
    private BigDecimal money;
 
    /**
     * 抢红包时间
     */
    private Date getDate;
}

php复制代码/**
 * 发红包
 * @author keying
 * @date 2021/6/22
 */
@Data
public class SendRedpack {
    /**
     *
     */
    private Integer id;
 
    /**
     * 发红包用户
     */
    private String userId;
 
    /**
     * 红包金额
     */
    private BigDecimal money;
 
    /**
     * 单个红包金额
     */
    private BigDecimal unitMoney;
 
    /**
     * 红包个数
     */
    private Integer total;
 
    /**
     * 红包剩余个数
     */
    private Integer remain;
 
    /**
     * 发红包时间
     */
    private Date sendDate;
 
}

less复制代码/**
 * 生产者
 *
 * @author keying
 * @date 2021/6/22
 */
@RestController
@Slf4j
@RequestMapping("/provider")
public class ProviderController {
 
    @Resource
    private RabbitMqService rabbitMqService;
 
    @RequestMapping("/send_redpack")
    public void sendRedpack(){
        for (int i = 0; i < 100; i++) {
            rabbitMqService.sendRedpack(i);
        }
 
    }
 
}
 
 
@Resource
    private RabbitTemplate rabbitTemplate;
 
    @Override
    public void sendRedpack(int i) {
        rabbitTemplate.convertAndSend("redpack", i);
    }

java复制代码/**
 * 消费
 *
 * @author keying
 * @date 2021/6/22
 */
@Component
@Slf4j
public class ConsumerRabbitMq {
 
    @Resource
    private RabbitMqMapper rabbitMqMapper;
 
    private static final String sendUserId = "001";
    /**
     * 需在RabbitMQ中手动创建redpack 队列，否则报错
     * @param message
     */
    @RabbitListener(queues = "redpack")
    public void getRedpack(String message){
        log.info("接收的消费红包人员: {}", message);
        try {
            //查询红包剩余个数是否大于0
            int remain = rabbitMqMapper.getRemain(sendUserId);
            if(remain > 0) {
                //扣减红包个数
                int result = rabbitMqMapper.deleteOne(sendUserId);
                if(result > 0) {
                    //3.新增用户抢红包记录
                    GetRedpack getRedpack = new GetRedpack();
                    getRedpack.setUserId(message);
                    getRedpack.setSendRedpackId(sendUserId);
                    getRedpack.setGetDate(new Date());
                    getRedpack.setMoney(new BigDecimal("10"));
                    rabbitMqMapper.insertGetRedpack(getRedpack);
                }
 
            }
            //异步通知用户抢红包成功
        } catch (Exception e) {
            log.error("处理抢单异常：" + e.getMessage());
            throw new RuntimeException("处理抢单异常");
        }
    }
}


 
    <select id="getRemain" parameterType="java.lang.String" resultType="java.lang.Integer">
        select remain from send_redpack where user_id = #{sendUserId}
    </select>
 
    <delete id="deleteOne" parameterType="java.lang.String">
        update send_redpack set remain = remain-1 where user_id = #{sendUserId}
    </delete>
 
    <insert id="insertGetRedpack" parameterType="com.alibaba.first.model.GetRedpack">
        insert into get_redpack (user_id,send_redpack_id,money,get_date)
        values (#{userId},#{sendRedpackId},#{money},#{getDate})
    </insert>

复制代码python语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了python的多线程编程。

python复制代码import threading

python复制代码import threading
def main():
    print(threading.current_thread())

if __name__ == '__main__':
    main()

python复制代码结果：1#我的就一个你的呢？

python复制代码import threading
def main():
    print(threading.active_count())
    print(threading.enumerate())
   

if __name__ == '__main__':
    main()

python复制代码>>>[<_MainThread(MainThread, started 36004)>]#返回的是一个列表因为我的目前就一个所以就一个主进程

python复制代码import threading
def main():
    print(threading.active_count())
    print(threading.enumerate())
    print(threading.current_thread())

if __name__ == '__main__':
    main()

python复制代码>1
[<_MainThread(MainThread, started 36004)>]
<_MainThread(MainThread, started 36004)>

python复制代码import threading
def first():
    print("frist active")
    print("frist finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    first_thread.start()#开始的标志
    print("main")

if __name__ == '__main__':
    main()

python复制代码结果：
第一次运行
frist active
main
frist finish
第二次运行
frist active
frist finish
main

python复制代码import time

python复制代码import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    first_thread.start()
    print("main")

if __name__ == '__main__':
    main()

python复制代码结果：
frist active
main
frist finish

python复制代码    class MyThread(threading.Thread):
        def __init__(self,n):
            super(MyThread,self).__init__()   #重构run函数必须写
            self.n = n

        def run(self):
            print('task',self.n)
            time.sleep(1)
            print('2s')
            time.sleep(1)
            print('1s')
            time.sleep(1)
            print('0s')
            time.sleep(1)

    if __name__ == '__main__':
        t1 = MyThread('t1')
        t2 = MyThread('t2')
        t1.start()
        t2.start()