2-2-3-1、深入理解Java线程

目录

  • Java线程
    • Java线程的实现方式
      • 使用 Thread类或继承Thread类
      • 实现 Runnable 接口配合Thread
      • 使用有返回值的 Callable
      • 使用 lambda
    • Java线程实现原理
    • Java线程属于内核级线程
      • 内核级线程(Kernel Level Thread ,KLT)
      • 用户级线程(User Level Thread,ULT)
    • Java线程的调度机制
      • 协同式线程调度
      • 抢占式线程调度
      • Java线程调度就是抢占式调度
    • Java线程的生命周期
    • Thread常用方法
      • sleep方法
      • yield方法
      • join方法
      • stop方法
      • Java线程的中断机制
        • API的使用
        • 阻塞线程的中断
    • Java线程间通信
      • volatile
      • 等待唤醒(等待通知)机制
      • 管道输入输出流
      • Thread.join
  • 协程
    • 定义
    • 协程的特点

Java线程

Java线程的实现方式

思考:Java中实现线程有几种方式
Java中实现线程的方式本质上只有一种:由于java中的线程依赖于操作系统线程的创建,因此,不管使用什么方式实现线程,最后都是通过操作系统的pthread_create方法来创建
但可以通过不同的场景对任务有不同的使用方式

使用 Thread类或继承Thread类

// 创建线程对象
Thread t = new Thread() {
	public void run() {
		// 要执行的任务
	}
};
// 启动线程
t.start();

实现 Runnable 接口配合Thread

把【线程】和【任务】(要执行的代码)分开

  • Thread 代表线程对象
  • Runnable 可运行的任务(线程要执行的代码)对象
Runnable runnable = new Runnable() {
    public void run(){
    // 要执行的任务
    }
};
// 创建线程对象
Thread t = new Thread(runnable);
// 启动线程
t.start();

使用有返回值的 Callable

class CallableTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return new Random().nextInt();
    }
}
//创建线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//提交任务,并用 Future提交返回结果
Future<Integer> future = service.submit(new CallableTask());

使用 lambda

new Thread(()> System.out.println(Thread.currentThread().getName())).start();

本质上Java中实现线程只有一种方式,都是通过new Thread()创建线程,调用Thread#start启动线程最终都会调用Thread#run方法

Java线程实现原理

思考:Java线程执行为什么不能直接调用run()方法,而要调用start()方法
由于Java的线程创建需要依赖于操作系统,因此直接调用run()方法其实只是简单的方法调用,而调用start()方法是告诉操作系统按照我提供的java线程对象创建一个线程A,并将它加入就绪列表,参与cpu调度,如果线程A获取到cpu的执行权之后,就会通过jvm调用java线程对象的run方法,完成对Java线程对象run方法的异步调用
对于线程创建的详情,查看Thread#start()源码分析

Java线程属于内核级线程

基于操作系统原生线程模型来实现。Sun JDK,它的Windows版本和Linux版本都使用一对一的线程模型实现,一条Java线程就映射到一条轻量级进程之中

内核级线程(Kernel Level Thread ,KLT)

它们是依赖于内核的,即无论是用户进程中的线程,还是系统进程中的线程,它们的创建、撤消、切换都由内核实现

用户级线程(User Level Thread,ULT)

操作系统内核不知道应用线程的存在

2-2-3-1、深入理解Java线程_第1张图片

Java线程的调度机制

线程调度是指系统为线程分配处理器使用权的过程,主要调度方式分两种,分别是协同式线程调度和抢占式线程调度

协同式线程调度

线程执行时间由线程本身来控制,线程把自己的工作执行完之后,要主动通知系统切换到另外一个线程上。最大好处是实现简单,且切换操作对线程自己是可知的,没啥线程同步问题。坏处是线程执行时间不可控制,如果一个线程有问题,可能一直阻塞在那里

抢占式线程调度

每个线程将由系统来分配执行时间,线程的切换不由线程本身来决定(Java中,Thread.yield()可以让出执行时间,但无法获取执行时间)。线程执行时间系统可控,也不会有一个线程导致整个进程阻塞

Java线程调度就是抢占式调度

希望系统能给某些线程多分配一些时间,给一些线程少分配一些时间,可以通过设置线程优先级来完成。Java语言一共10个级别的线程优先级(Thread.MIN_PRIORITY至Thread.MAX_PRIORITY),在两线程同时处于ready状态时,优先级越高的线程越容易被系统选择执行。但优先级并不是很靠谱,因为Java线程是通过映射到系统的原生线程上来实现的,所以线程调度最终还是取决于操作系统
例如:

/**
 * 一个简单卖票程序:多个窗口卖票
 */
public class SellTicketDemo implements Runnable {
    //车票
    private int ticket;
    public SellTicketDemo() {
        this.ticket = 1000;
    }
    @Override
    public void run() {
        while (ticket > 0) {
            synchronized (this) {
                if (ticket > 0) {
                    try {
                        // 线程进入暂时的休眠
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 获取到当前正在执行的程序的名称,打印余票
                    System.out.println(Thread.currentThread().getName() + ":正在执行操作,余票:" + ticket--);
                }
            }
            Thread.yield();
        }
    }
    public static void main(String[] args) {
        SellTicketDemo demo = new SellTicketDemo();
        Thread thread1 = new Thread(demo, "thread1");
        Thread thread2 = new Thread(demo, "thread2");
        Thread thread3 = new Thread(demo, "thread3");
        Thread thread4 = new Thread(demo, "thread4");
        //priority优先级默认是5,最低1,最高10
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread3.setPriority(Thread.MIN_PRIORITY);
        thread4.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

Java线程的生命周期

Java 语言中线程共有六种状态,分别是:

  1. NEW(初始化状态)
  2. RUNNABLE(可运行状态+运行状态)
  3. BLOCKED(阻塞状态)
  4. WAITING(无时限等待)
  5. TIMED_WAITING(有时限等待)
  6. TERMINATED(终止状态)

在操作系统层面,Java 线程中的 BLOCKED、WAITING、TIMED_WAITING 是一种状态,即前面我们提到的休眠状态。也就是说只要 Java 线程处于这三种状态之一,那么这个线程就永远没有 CPU 的使用权

2-2-3-1、深入理解Java线程_第2张图片


从JavaThread的角度,JVM定义了一些针对Java Thread对象的状态(jvm.h)

2-2-3-1、深入理解Java线程_第3张图片


从OSThread的角度,JVM还定义了一些线程状态给外部使用,比如用jstack输出的线程堆栈信息中线程的状态(osThread.hpp)

2-2-3-1、深入理解Java线程_第4张图片

Thread常用方法

sleep方法

  • 调用 sleep 会让当前线程从 Running 进入TIMED_WAITING状态,不会释放对象锁
  • 其它线程可以使用 interrupt 方法打断正在睡眠的线程,这时 sleep 方法会抛出InterruptedException,并且会清除中断标志
  • 睡眠结束后的线程未必会立刻得到执行
  • sleep当传入参数为0时,和yield相同

yield方法

  • yield会释放CPU资源,让当前线程从 Running 进入 Runnable状态,让优先级更高(至少是相同)的线程获得执行机会,不会释放对象锁
  • 假设当前进程只有main线程,当调用yield之后,main线程会继续运行,因为没有比它优先级更高的线程
  • 具体的实现依赖于操作系统的任务调度器

join方法

等待调用join方法的线程结束之后,程序再继续执行,一般用于等待异步线程执行完结果之后才能继续运行的场景
例如:

public class ThreadJoinDemo {
    public static void main(String[] sure) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("t begin");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t finished");
        });
        long start = System.currentTimeMillis();
        t.start();
        //主线程等待线程t执行完成
        t.join();
        System.out.println("执行时间:" + (System.currentTimeMillis() - start));
        System.out.println("Main finished");
    }
}

思考:如何正确优雅的停止线程
Java线程类型提供了停止线程的方法stop(),但是stop会有任务未执行完,强行停止的问题,一次,我们会借助中断标志位来进行优雅的停止线程

stop方法

stop()方法已经被jdk废弃,原因就是stop()方法太过于暴力,强行把执行到一半的线程终止

public class ThreadStopDemo {
    private static final Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName() + "获取锁");
                    try {
                        Thread.sleep(60000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "执行完成");
            }
        });
        thread.start();
        Thread.sleep(2000);
        // 停止thread,并释放锁
        thread.stop();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "等待获取锁");
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName() + "获取锁");
                }
            }
        }).start();
    }
}

stop会释放对象锁,可能会造成数据不一致

Java线程的中断机制

Java没有提供一种安全、直接的方法来停止某个线程,而是提供了中断机制。中断机制是一种协作机制,也就是说通过中断并不能直接终止另一个线程,而需要被中断的线程自己处理。被中断的线程拥有完全的自主权,它既可以选择立即停止,也可以选择一段时间后停止,也可以选择压根不停止

API的使用
  • interrupt():将线程的中断标志位设置为true,不会停止线程
  • isInterrupted(): 判断当前线程的中断标志位是否为true,不会清除中断标志位
  • Thread.interrupted():判断当前线程的中断标志位是否为true,并清除中断标志位,重置为fasle

中断机制简单应用示例:

/**
 * 中断机制
 */
public class ThreadInterruptTest {
    static int i = 0;
    public static void main(String[] args)  {
        System.out.println("begin");
        Thread t1 = new Thread(() -> {
            do {
                i++;
                System.out.println(i);
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //Thread.interrupted()  清除中断标志位
                //Thread.currentThread().isInterrupted() 不会清除中断标志位
                if (Thread.interrupted()) {
                    System.out.println("=========");
                }

            } while (i != 10);
        });
        t1.start();
        //不会停止线程t1,只会设置一个中断标志位 flag=true
        t1.interrupt();
    }
}

对于借助中断标志位来中断线程的方式如下:

public class ThreadStopDemo2 implements Runnable {
    @Override
    public void run() {
        int count = 0;
        while (!Thread.currentThread().isInterrupted() && count < 1000) {
            System.out.println("count = " + count++);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
                //重新设置线程中断状态为true
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("线程停止: stop thread");
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadStopDemo2());
        thread.start();
        Thread.sleep(5);
        thread.interrupt();
    }
}

注意:使用中断机制时一定要注意是否存在中断标志位被清除的情况

阻塞线程的中断

针对上面的代码示例,我们可以看出,一般阻塞的线程都是需要捕获中断异常,一旦修改当前线程的中断标志位,当前线程就会收到中断信号,随即抛出中断异常,而我们的中断业务就需要在异常中进行处理

Java线程间通信

volatile

volatile有两大特性,一是可见性,二是有序性,禁止指令重排序,其中可见性就是可以让线程之间进行通信
示例如下:

public class VolatileDemo {
    private static volatile boolean flag = true;
    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                if (flag) {
                    System.out.println("run on");
                    flag = false;
                }
            }
        }).start();
        new Thread(() -> {
            while (true) {
                if (!flag) {
                    System.out.println("run off");
                    flag = true;
                }
            }
        }).start();
    }
}

等待唤醒(等待通知)机制

  • 等待唤醒机制可以基于wait和notify方法来实现,在一个线程内调用该线程锁对象的wait方法,线程将进入等待队列进行等待直到被唤醒
public class WaitDemo {
    private static final Object lock = new Object();
    private static volatile boolean flag = true;
    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (lock){
                while (flag){
                    try {
                        System.out.println("wait start .......");
                        //等待
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("wait end ....... ");
            }
        }).start();
        new Thread(() -> {
            if (flag){
                synchronized (lock){
                    if (flag){
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //通知
                        lock.notifyAll();
                        System.out.println("notify .......");
                        flag = false;
                    }
                }
            }
        }).start();
    }
}
  • LockSupport是JDK中用来实现线程阻塞和唤醒的工具,线程调用park则等待“许可”,调用unpark则为指定线程提供“许可”。使用它可以在任何场合使线程阻塞,可以指定任何线程进行唤醒,并且不用担心阻塞和唤醒操作的顺序,但要注意连续多次唤醒的效果和一次唤醒是一样的
public class LockSupportTest {
    public static void main(String[] args) {
        Thread parkThread = new Thread(new ParkThread());
        parkThread.start();

        System.out.println("唤醒parkThread");
        //为指定线程parkThread提供“许可”
        LockSupport.unpark(parkThread);
    }
    static class ParkThread implements Runnable {
        @Override
        public void run() {
            System.out.println("ParkThread开始执行");
            // 等待“许可”
            LockSupport.park();
            System.out.println("ParkThread执行完成");
        }
    }
}

管道输入输出流

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于,它主要用于线程之间的数据传输,而传输的媒介为内存。管道输入/输出流主要包括了如下4种具体实现:
PipedOutputStream、PipedInputStream、PipedReader和PipedWriter,前两种面向字节,而后两种面向字符

public class PipedTest {
    public static void main(String[] args) throws Exception {
        PipedWriter out = new PipedWriter();
        PipedReader in = new PipedReader();
        // 将输出流和输入流进行连接,否则在使用时会抛出IOException
        out.connect(in);
        Thread printThread = new Thread(new Print(in), "PrintThread");
        printThread.start();
        int receive;
        try {
            while ((receive = System.in.read()) != -1) {
                out.write(receive);
            }
        } finally {
            out.close();
        }
    }
    static class Print implements Runnable {
        private final PipedReader in;
        public Print(PipedReader in) {
            this.in = in;
        }
        @Override
        public void run() {
            int receive;
            try {
                while ((receive = in.read()) != -1) {
                    System.out.print((char) receive);
                }
            } catch (IOException ex) {
            }
        }
    }
}

Thread.join

join可以理解成是线程合并,当在一个线程调用另一个线程的join方法时,当前线程阻塞等待被调用join方法的线程执行完毕才能继续执行,所以join的好处能够保证线程的执行顺序,但是如果调用线程的join方法其实已经失去了并行的意义,虽然存在多个线程,但是本质上还是串行的,最后join的实现其实是基于等待通知机制的
详细示例查看上面的ThreadJoinDemo

协程

定义

协程,英文Coroutines, 是一种基于线程之上,但又比线程更加轻量级的存在,协程不是被操作系统内核所管理,而完全是由程序所控制(也就是在用户态执行),具有对内核来说不可见的特性。这样带来的好处就是性能得到了很大的提升,不会像线程切换那样消耗资源

2-2-3-1、深入理解Java线程_第5张图片


子程序,或者称为函数,在所有语言中都是层级调用,比如A调用B,B在执行过程中又调用了C,C执行完毕返回,B执行完毕返回,最后是A执行完毕。而协程的调用和子程序不同。协程在子程序内部是可中断的,然后转而执行别的子程序,在适当的时候再返回来接着执行
例如以下代码:

def A():
 print '1'
 print '2'
 print '3'
def B():
 print 'x'
 print 'y'
 print 'z'

假设由协程执行,在执行A的过程中,可以随时中断,去执行B,B也可能在执行过程中中断再去执行A,结果可能是:1 2 x y 3 z

协程的特点

协程的特点在于是一个线程执行,与多线程对比的优势:

  • 线程的切换由操作系统调度,协程由用户自己进行调度,因此减少了上下文切换,提高了效率
  • 线程的默认stack大小是1M,而协程更轻量,接近1k。因此可以在相同的内存中开启更多的协程
  • 不需要多线程的锁机制:因为只有一个线程,也不存在同时写变量冲突,在协程中控制共享资源不加锁,只需要判断状态就好了,所以执行效率比多线程高很多

注意: 协程适用于被阻塞的,且需要大量并发的场景(网络io)。不适合大量计算的场景

你可能感兴趣的:(进阶,并发编程-JDK,java,线程,内核线程,用户线程,线程状态)