Thread线程入门

1. 构造函数

1. Thread(Runnable target, String name)
   分配一个任务给到线程，并给线程起名，还可以用getName()方法获取String类型的名字
2. Thread(String name)
   传入名称
3. Thread() 无参数构造函数

⚠️注意

public class Main {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.run();
    }
}

class MyThread extends Thread {
    public void run() {
        System.out.println("hello");
    }
}

直接调用run()方法，相当于调用了一个普通的Java方法，当前线程并没有任何改变，也不会启动新线程。代码实际上是在main()方法内部又调用了run()方法，打印hello语句是在main线程中执行的，没有任何新线程被创建。

**必须调用Thread实例的start()方法才能启动新线程!**如果我们查看Thread类的源代码，会看到start()方法内部调用了一个private native void start0()方法，native修饰符表示这个方法是由JVM虚拟机内部的C代码实现的，不是由Java代码实现的。

2.常用静态方法和属性

1. getId()返回线程标识ID
2. getPriority() 获取线程优先级
3. setPriority() 设置线程优先级

• 默认优先级 NORM_PRIORITY
• 最大优先级 MAX_PRIORITY
• 最小优先级 MIN_PRIORITY

4.停止线程的方法 stop()【已经被弃用】方法本身是不安全的，因为如果某个线程正在进行IO操作，突然被关闭，导致资源未被释放。 可以通知线程当其中的某个变量值 如果达到某个异常值之后来结束run()方法
5.sleep(long millisecond)方法使得线程暂时休眠 多少毫秒（比如每隔1s输出一个数字）
6. setDaemon()设置守护线程，线程实质上分为用户线程和守护（守护用户的）线程，守护线程是在所有用户线程死亡后才会消失

Thread的六种状态

Enum Thread.State

1. NEW: 线程被创建尚未启动
2. RUNNABLE: 在JAVA虚拟机中正在执行的线程
3. BLOCKED: 线程被阻塞，等待监视器锁定（处于排队状态）排队结束后会回到RUNNABLE状态，或者抢占不到时间片被阻塞
4. WAITING: 线程处于等待
5. TIMED_WAITING:线程计时多少毫秒后取消等待
6. TERMINATED:线程被杀死

带返回值的线程Callable （第三种线程实现方式）

Interface Callable 主线程指派了一个任务，最后返回结果给启动该线程的线程
get()获取线程执行的结果，必须使得主线程暂停，知道该线程运行得到结果
启动Callable线程的步骤

1. 实现Callable接口
2. Callable c = new MyCallable();
3. FutureTask task = new FutureTask<>©;
4. new Thread(task).start();
5. T t = task.get(); //使得main线程停下来

线程池（装载线程的容器）

##为什么要用线程池？原因很简单，性能好，而且不用自己费心费力的管理线程

 1、线程池基本说明及定义
  从JDK 1.5开始，添加了Executors工具类，这个类定义了Executor、ExecutorService、ScheduledExecutorService、ThreadFactory、Calable类的工厂和实用方法。在Executors类的源码注释中，这样写道：

  该类包含：
  1. 提供能够创建并返回设置了常用配置的ExecutorService的方法
  2. 提供能够创建并返回设置了常用配置的ScheduledExecutorService的方法
  3. 提供能够创建并返回一个经过包装（禁用了特定的实现方法，仅仅暴露ExecutorService的实现）的ExecutorService方法
  4. 提供能够创建并返回能修改新建线程状态的ThreadFactory的方法
  5. 提供能够创建并返回非闭包形式的Callable，因此能够在需要Callable的执行方法中使用

无论是哪一种线程池都是ExecutorService类型
创建线程池依靠Executors类的静态方法：service.execute(Runnable r)
一个多线程程序的流程包括如下：

• 创建线程
• 创建任务
• 执行任务
• 关闭线程

如果花费的时间主要在创建线程和关闭线程，频繁地创建线程降低系统效率，而线程池中的线程可以反复的使用
如：线程数组 {A, B, C, D}，线程有闲/忙的状态
任务列表 (加入任务)：{1，2，3，4，5，6}
线程领取了任务后会切换为忙的状态
当所有任务都没被领取，即所有线程处于忙，那么任务就会排队

缓存线程池 （变长线程池）

package multithreads;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;


public class ThreadPool {
    public static void main(String[] args) {
    	//不需要new，直接调用Executors静态方法
        ExecutorService service = Executors.newCachedThreadPool();//创建缓存线程池
        
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行");
            }
        });
       
        /**
         * 由于sleep使得主线程休眠，然后其他线程执行完毕后就有多余的空闲线程可用于执行任务
         */
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行");
            }
        });
    }
}

定长线程池 【适用于并发任务】

执行流程：
1.判断线程池中是否有空闲线程池
2.存在即使用
3.不存在空闲线程，且线程池未满，则创建线程然后加入使用
4.不存在空闲线程，且线程池满，则等待空闲线程

package multithreads;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class ThreadPool {
    public static void main(String[] args) {
    	//不需要new，直接调用Executors静态方法
        ExecutorService service = Executors.newFixedThreadPool(2);//创建2个线程大小的线程池
        
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行");
            }
        });
       
        /**
         * 由于sleep使得主线程休眠，然后其他线程执行完毕后就有多余的空闲线程可用于执行任务
         */
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行");
            }
        });
    }
}

单线程线程池（任务需要子线程排队执行）

线程池会一直等待任务，但是一定时间后也会关闭

package multithreads;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;


public class CachedThreadPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行");
            }
        });
       
        /**
         * 由于sleep使得主线程休眠，然后其他线程执行完毕后就有多余的空闲线程可用于执行任务
         */
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行");
            }
        });
    }
}

周期性任务定长线程池

使用的仍是Executors类来创建，但是其对象是ScheduledExecutorService类别的（这个类是ExecutorService的子类）
1.定时执行一次：

package multithreads;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("楚河汉界");
            }
        },3, TimeUnit.SECONDS);//3秒后自动执行一次
    }
}

2.定时后周期性执行
为了简化代码，可以使用Lambda表达式（函数式编程的思想），即将匿名内部类 用 Lambda表达式的方式改写
改写格式

(参数列表) -> {函数体内容；return 返回值；}

然后利用这个我们设置一个1秒后开始执行，每隔三秒运行任务的线程Thread-0

public class ScheduledThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        
        service.scheduleAtFixedRate(() -> {System.out.println("test");},5,1,TimeUnit.SECONDS);
    }
}