1、创建线程的方式
三种方式，分别为: 继承Thread，实现Runable，实现Callable<T>
/**
* @Todo
* @Author lzj
* @Date 2021-02-26 15:17
*/
public class Mythread extends Thread {
@Override
public void run() {
super.run();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("aa");
}
}
class Mythread1 implements Runnable{
@Override
public void run() {
try {
Thread.sleep(2000);
System.out.println("bb");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Mythread3 implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("cc");
return "cc";
}
}
class Test{
public static void main(String[] args) {
//继承Thread
Mythread mythread = new Mythread();
mythread.start();
//实现Runnable<T>
Mythread1 mythread1 = new Mythread1();
new Thread(mythread1).start();
//实现Callable<T>
Mythread3 mythread3 = new Mythread3();
FutureTask<String> futureTask = new FutureTask<String>(mythread3);
new Thread(futureTask).start();
}
}
这三种方式的区别在于使用的接口或类不同，继承Thread类和实现Runnable接口都是通过重写run()方法来定义线程的执行逻辑，而使用Callable和Future可以获得线程的执行结果。此外，使用Runnable接口可以更好地实现代码的解耦，而使用Callable和Future可以更方便地获取线程的执行结果。
2、线程生命周期
- 新建new : 分配好内存
- 就绪runable: 线程已经被启动，等待CPU分配时间片
- 运行running: 线程获得CPU资源正在执行任务
- 堵塞blocked: 由于某种原因CPU让出资源，暂停自己的执行。
sleep()时间过去、wait() 后被notify()重新进入就绪。- 死亡dead: 线程执行完毕或者被其它线程杀死。
run()执行完毕， 或者强行stop()
3、线程中断机制
是一种协同机制。需要由在其它线程中调用该线程的中断interrupt。
代码demo:
class MyThread4 extends Thread{
@Override
public void run() {
boolean stop = true;
while (stop){
try {
System.out.println("MyThread is running...");
} catch (Exception e) {
e.printStackTrace();
}
//线程中自己处理终端后的逻辑，不处理不会中断
if(Thread.currentThread().isInterrupted()){
System.out.println("jieshu");
break;
}
}
}
public static void main(String[] args) throws InterruptedException {
MyThread4 m = new MyThread4();
m.start();
Thread.sleep(3000);
//main主线程中让线程m调用中断api
m.interrupt();
}
}
4、守护线程
相当于后台挂起独立运行，主线程退出后他自己还在运行（如果还没执行完的话）。进程结束，自己会结束。不需要关心和通知它做什么。
setDaemon(true) 即可设置为守护线程。
5、队列：线程阀
- BlockingQueue： 阻塞队列，会有一个阻塞作用 ：为空时，获取元素的线程等待非空。队列为满时，存储元素的线程等待可用。
- ArrayBlockigQueue： 数组阻塞队列，遵循FIFO(先进先出)，需要指定大小，为满时，放元素的线程阻塞等待，为空时，取元素的线程阻塞等待。
- LinkedBlockingQueue：进出端分别是独立的锁控制同步，这样存取数据可并行处理，可以高效处理并发数据。（不指定大小时，默认大小Integer.MAX_VALUE。如果存的速度大于取的速度，可能会塞满导致内存耗尽，所以最好设定大小）。
6、Thread常用api 使用介绍
- yield() , join() , sleep()
https://blog.csdn.net/weixin_39027589/article/details/81215929
