Java 线程相关总结

1. 简介

本文总结一下Java中线程相关的知识。

2.线程的状态

‌Java线程有六种状态‌：

‌NEW状态‌：线程对象已被创建，但尚未启动。 ‌
RUNNABLE状态‌：1.线程已经准备好，随时可以被CPU执行。2.线程正在执行。
TERMINATED状态‌：线程已经执行完毕，被终止。 ‌
WAITING状态‌：线程正在等待某个条件成立，以便继续执行。
TIMED_WAITING状态‌：线程在等待某个条件成立，但有一个超时时间。
BLOCKED状态‌：线程由于锁竞争而阻塞，无法执行。

3. 常用方法

//创建线程
MyThread1 t1 = new MyThread1();//自定义线程类创建线程，自定义线程类需要继承Thread，并重新覆盖run方法

Thread t2 = new Thread(()->{//匿名函数创建线程
    System.out.println("线程执行");
});
Thread t3 = new Thread(new Runnable() {//匿名runnable创建线程
    @Override
    public void run() {
        System.out.println("线程8执行");
    }
});

t1.start();//线程启动
Thread.sleep(3000);//休眠线程

4. Join方法

join方法用于将当前线程挂起，等待对应线程执行完成，用于安排线程执行先后顺序。

public class Main {
    //FileNotFoundException, IOException
    public static void main(String[] args) throws Exception {
        //线程串行执行
        MyThread1 t1 = new MyThread1();
        MyThread1 t2 = new MyThread1();

        t1.start();
        t2.start();
        
        t2.join();//t2先执行
        t1.join();//t1后执行
        System.out.println(Thread.currentThread().getName());//主函数最后执行
    }
}

//声明自定义线程类
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

5. synchronized同步机制

5.1 synchronized代码块

synchronized代码块相当于创建一个锁的临界区，用于线程间的同步操作：

public class Main {
    public static void main(String[] args) throws Exception {
        Num num = new Num();
        User user = new User(num);
        user.start();

        Bank bank = new Bank(num);
        bank.start();
    }
}

class Num {

}

class Bank extends Thread{
    private Num num;
    public Bank(Num num){
        this.num = num;
    }
    public void run(){
        synchronized (num){//synchronized包裹的区域是临界区
            try{
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("开始叫号");
            num.notifyAll();//通知
        }
    }
}

class User extends Thread{
    private Num num;
    public User(Num num){
        this.num = num;
    }
    public  void run(){
        synchronized ( num ){//synchronized包裹的区域是临界区
            System.out.println("银行还没开门，需要等一会");
            try {
                num.wait();//休眠，等待通知，wait方法只能在synchronized块中使用
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("该我了");
        }
    }
}

5.2 synchronized修饰方法

synchronized用在方法的前面代表，该方法同一时刻只能被一个线程访问：

public synchronized void test(){}

6. 线程池

线程池的常用类型总结如下：

ExecutorService executorService = Executors.newFixedThreadPool(3);//创建固定个数线程，如果执行线程数超出个数，则阻塞。
ExecutorService executorService = Executors.newCachedThreadPool();//根据需求动态创建线程，如果线程池数量不够，则动态创建新线程。
ExecutorService executorService = Executors.newSingleThreadExecutor();//只有一个线程，用于有先后顺序要求的场景
ExecutorService executorService = Executors.newScheduledThreadPool(3);//定时调度线程，延迟执行，重复执行等。

for(int i = 0; i < 30; i++) {
    executorService.submit(new Runnable() {//执行线程
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    });
}