JAVA多线程

Dioker

于 2021-09-29 10:50:49 发布

阅读量117

点赞数

文章标签： java

原文链接：https://www.runoob.com/java/java-multithreading.html

版权

1.一个线程的生命周期

新建状态

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态
- 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
- 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
- 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
死亡状态

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

2.线程优先级

每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

3.创建线程

创建线程有三种方式:

通过实现 Runnable 接口；
通过继承 Thread 类本身；
通过 Callable 和 Future 创建线程。

1)通过实现Runnable接口

创建一个实现 Runnable 接口的类,该类需要实现run()方法:

public void run()

实现该方法后,就可以在此类中实例化线程对象,最常使用的构造方法

Thread(Runnable threadOb,String threadName);

threadOb 是一个实现 Runnable 接口的类的实例，threadName 指定新线程的名字。

新线程创建后,调用它的start()方法才会运行

void start();

接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。
实现步骤：①、定义类实现Runnable接口
　　　　　②、覆盖Runnable接口中的run方法
　　　　　　　　　将线程要运行的代码放在该run方法中。
　　　　　③、通过Thread类建立线程对象。
　　　　　④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
　　　　　　　　　自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确run方法所属对象
　　　　　⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

代码示例:

class testMyRunnable1 implements Runnable{
    private int count = 7;

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            if (this.count>0) {
                System.out.println(Thread.currentThread().getName()+"-1 剩余: " + this.count--);
            }
        }
    }

}
public class testRunnable1 {
    public static void main(String[] args) {
        testMyRunnable1 T1 = new testMyRunnable1();
        new Thread(T1,"1号:").start();
        new Thread(T1,"2号:").start();
        new Thread(T1,"3号:").start();
    }
}

通过继承Thread来创建线程

创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

步骤：①、定义类继承Thread；
　　　②、复写Thread类中的run方法；
目的：将自定义代码存储在run方法，让线程运行
　　　③、调用线程的start方法：
该方法有两步：启动线程，调用run方法。

class MyThread1 extends Thread{
    private Thread t;
    private final String threadName;

    public MyThread1(String threadName) {
        this.threadName = threadName;
    }

    @Override
    public void run() {
        System.out.println("Running "+threadName);
        try {
            for (int i=4;i>0;i--){
                System.out.println("Thread: "+threadName+", "+i);
                //线程休眠
                Thread.sleep(50);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("Thread "+threadName+" exiting");
    }

    @Override
    public synchronized void start() {
        System.out.println("Starting "+threadName);
        if (t==null){
            t=new Thread(this,threadName);
            t.start();
        }
    }
}

public class testThread {
    public static void main(String[] args) {
        MyThread1 T1 = new MyThread1("Thread-1");
        T1.start();
        MyThread1 T2 = new MyThread1("Thread-2");
        T2.start();
    }
}

Thread和Runnable的区别：
        如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
实现Runnable接口比继承Thread类所具有的优势：
        1）：适合多个相同的程序代码的线程去处理同一个资源
        2）：可以避免java中的单继承的限制
        3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

通过 Callable 和 Future 创建线程

实现步骤：
        ①、创建Callable接口的实现类，并实现call()方法，改方法将作为线程执行体，且具有返回值。
        ②、创建Callable实现类的实例，使用FutrueTask类进行包装Callable对象，FutureTask对象封装了Callable对象的call()方法的返回值
        ③、使用FutureTask对象作为Thread对象启动新线程。
        ④、调用FutureTask对象的get（）方法获取子线程执行结束后的返回值。

线程状态管理

1.线程休眠--sleep

线程睡眠的原因：线程执行的太快，或需要强制执行到下一个线程。
线程睡眠的方法（两个）：(1000毫秒是1秒)

sleep（long millis）在指定的毫秒数内让正在执行的线程休眠。
sleep（long millis，int nanos）在指定的毫秒数加指定的纳秒数内让正在执行的线程休眠。

PS : 使用sleep方法之后，线程是进入阻塞状态的，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态，是由系统控制的，我们不可能精准的去干涉它，所以如果调用Thread.sleep(1000)使得线程睡眠1秒，可能结果会大于1秒。

2.线程让步--yield

该方法和sleep方法类似，也是Thread类提供的一个静态方法，可以让正在执行的线程暂停，但是不会进入阻塞状态，而是直接进入就绪状态。相当于只是将当前线程暂停一下，然后重新进入就绪的线程池中，让线程调度器重新调度一次。也会出现某个线程调用yield方法后暂停，但之后调度器又将其调度出来重新进入到运行状态。

sleep方法声明抛出InterruptedException，调用该方法需要捕获该异常。yield没有声明异常，也无需捕获。

3.线程合并--join

thread.join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的join()方法，直到线程A执行完毕后，才会继续执行线程B。待此线程执行完成后，再执行其他线程，其他线程阻塞，可以想象成插队。

4.停止线程

使用interrupt方法中断线程。
在Thread.java类里提供了两种方法判断线程是否为停止的。
this.interrupted():测试当前线程是否已经中断（静态方法）。如果连续调用该方法，则第二次调用将返回false。在api文档中说明interrupted()方法具有清除状态的功能。执行后具有将状态标识清除为false的功能。
this.isInterrupted():测试线程是否已经中断，但是不能清除状态标识。

public void interrupt() 中断这个线程。
如果该线程阻塞的调用wait() ， wait(long) ，或wait(long, int)的方法Object类，或者在join() ， join(long) ， join(long, int) ， sleep(long) ，或sleep(long, int) ，这个类的方法，那么它的中断状态将被清除，并且将收到一个InterruptedException 。
如果该线程在可阻止在I / O操作InterruptibleChannel则信道将被关闭，该线程的中断状态将被设置，并且螺纹将收到一个ClosedByInterruptException 。
如果该线程在Selector中被阻塞，则线程的中断状态将被设置，并且它将从选择操作立即返回，可能具有非零值，就像调用了选择器的wakeup方法一样。
如果以前的条件都不成立，则该线程的中断状态将被设置。

5.线程优先级

java 中的线程优先级的范围是1～10，默认的优先级是5。与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的也并非没机会执行。

每个线程都有一个优先级。“高优先级线程”会优先于“低优先级线程”执行。每个线程都可以被标记为一个守护进程或非守护进程。在一些运行的主线程中创建新的子线程时，子线程的优先级被设置为等于“创建它的主线程的优先级”，当且仅当“创建它的主线程是守护线程”时“子线程才会是守护线程”。

当Java虚拟机启动时，通常有一个单一的非守护线程（该线程通过是通过main()方法启动）。JVM会一直运行直到下面的任意一个条件发生，JVM就会终止运行：
(1) 调用了exit()方法，并且exit()有权限被正常执行。
(2) 所有的“非守护线程”都死了(即JVM中仅仅只有“守护线程”)。

6.线程同步

同步方法1:

同步函数：就是用synchronize关键字修饰的方法。每个java对象都有一个内置锁，用synchronize关键字修饰方法时内置锁会保护整个方法，在调用该方法之前，要先获得内置锁，否则就会处于阻塞状态。

 public synchronized void run() {}

同步方法2：
同步代码块：就是拥有synchronize关键字修饰的语句块，被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。

synchronized (this){}

PS:

如果同步函数被静态修饰之后，使用的锁是什么？静态方法中不能定义this！
　　静态内存是：内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class 该对象类型是Class。
　　所以静态的同步方法使用的锁是该方法所在类的字节码文件对象。类名.class。代码如下：

public static test(String name){
    synchronized (Xxx.class) {
        Xxx.name = name;
    }
}

同步的前提：

　　1、必须要有两个或者两个以上的线程。
　　2、必须是多个线程使用同一个锁。
　　3、必须保证同步中只能有一个线程在运行。
　　4、只能同步方法，不能同步变量和类。
　　5、不必同步类中所有方法，类可以拥有同步和非同步的方法。
　　6、如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。
　　7、线程睡眠时，它所持的任何锁都不会释放。

好处：解决了多线程的安全问题。
弊端：多个线程需要判断，消耗资源，降低效率。

7.死锁

线程发生死锁可能性很小，即使看似可能发生死锁的代码，在运行时发生死锁的可能性也是小之又小。发生死锁的原因一般是两个对象的锁相互等待造成的。
进程A中包含资源A,进程B中包含资源B，A的下一步需要资源B，B的下一步需要资源A，所以它们就互相等待对方占有的资源释放，所以也就产生了一个循环等待死锁。

public class DeadLock {

    public static void main(String[] args) {
        Thread t1 = new Thread(new DeadLockTest(true));
        Thread t2 = new Thread(new DeadLockTest(false));
        t1.start();
        t2.start();
    }
}

class DeadLockTest implements Runnable{

    private boolean flag;
    static Object obj1 = new Object();
    static Object obj2 = new Object();
    public DeadLockTest(boolean flag) {
        this.flag = flag;
    }
    public void run(){
        if(flag){
            synchronized(obj1){
                System.out.println("if lock1");
                synchronized (obj2) {
                    System.out.println("if lock2");
                }
            }
        }else{
            synchronized (obj2) {
                System.out.println("else lock2");
                synchronized (obj1) {
                    System.out.println("else lock1");
                }
            }
        }
    }
 }

volatile关键字

volatile和synchronized特点

首先需要理解线程安全的两个方面：执行控制和内存可见。

执行控制的目的是控制代码执行（顺序）及是否可以并发执行。

内存可见控制的是线程执行结果在内存中对其它线程的可见性。根据Java内存模型的实现，线程在具体执行时，会先拷贝主存数据到线程本地（CPU缓存），操作完成后再把结果从线程本地刷到主存。

synchronized关键字解决的是执行控制的问题，它会阻止其它线程获取当前对象的监控锁，这样就使得当前对象中被synchronized关键字保护的代码块无法被其它线程访问，也就无法并发执行。更重要的是，synchronized还会创建一个内存屏障，内存屏障指令保证了所有CPU操作结果都会直接刷到主存中，从而保证了操作的内存可见性，同时也使得先获得这个锁的线程的所有操作，都happens-before于随后获得这个锁的线程的操作。

volatile关键字解决的是内存可见性的问题，会使得所有对volatile变量的读写都会直接刷到主存，即保证了变量的可见性。这样就能满足一些对变量可见性有要求而对读取顺序没有要求的需求。

使用volatile关键字仅能实现对原始变量(如boolen、 short 、int 、long等)操作的原子性，但需要特别注意， volatile不能保证复合操作的原子性，即使只是i++，实际上也是由多个原子操作组成：read i; inc; write i，假如多个线程同时执行i++，volatile只能保证他们操作的i是同一块内存，但依然可能出现写入脏数据的情况。

在Java 5提供了原子数据类型atomic wrapper classes，对它们的increase之类的操作都是原子操作，不需要使用sychronized关键字。

对于volatile关键字，当且仅当满足以下所有条件时可使用：

1. 对变量的写入操作不依赖变量的当前值，或者你能确保只有单个线程更新变量的值。
2. 该变量没有包含在具有其他变量的不变式中。

volatile和synchronized的区别

volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化