前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >JDK源码分析 多线程

JDK源码分析 多线程

作者头像
Yano_nankai
发布2018-10-08 10:42:34
2730
发布2018-10-08 10:42:34
举报
文章被收录于专栏:二进制文集

说明

对于JDK源码分析的文章,仅仅记录我认为重要的地方。源码的细节实在太多,不可能面面俱到地写清每个逻辑。所以我的JDK源码分析,着重在JDK的体系架构层面,具体源码可以参考:http://www.cnblogs.com/skywang12345/category/455711.html

实现多线程的两种方式

  • Thread
  • Runnable

优先使用 Runnable

因为 Thread 是类,一个类只能有一个父类,但是可以有多个接口。Runnable 有更好的扩展性。

Runnable 还可以用于“资源的共享”,如果多个线程是基于同一个 Runnable 对象建立的,它们会共享 Runnable 对象上的资源。

start() 和 run()的区别说明

  • start: 启动一个新的线程,新线程调用 run 方法。start 不能重复调用
  • run:和普通方法一样,可以重复调用。但是并不会启动新线程

测试代码

代码语言:javascript
复制
public class jdk {
    public static class MyThread extends Thread {
        public MyThread(String name) {
            super(name);
        }
        
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is running.");
        }
    }
    
    public static void main(String[] args) {
        Thread thread = new MyThread("myThread");
        
        System.out.println(Thread.currentThread().getName()+" call mythread.run()");
        thread.run();
        
        System.out.println(Thread.currentThread().getName()+" call mythread.start()");
        thread.start();
    }
}

输出:

代码语言:javascript
复制
main call mythread.run()
main is running
main call mythread.start()
mythread is running

分析:

main中,直接调用thread.run()时,仅仅是调用了MyThread实例的run()方法,并没有新建线程。所以run()方法中的Thread.currentThread().getName(),仍是main()!

而在调用thread.start()后,就会启动新的MyThread线程,并调用其中的run()方法,此时Thread.currentThread().getName()为新启动线程。

start 源码

代码语言:javascript
复制
public synchronized void start() {
    // 如果线程不是"就绪状态",则抛出异常!
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    // 将线程添加到ThreadGroup中
    group.add(this);
    boolean started = false;
    try {
        // 通过start0()启动线程
        start0();
        // 设置started标记
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
        }
    }
}

run 源码

代码语言:javascript
复制
public void run() {
    if (target != null) {
        target.run();
    }
}

wait(), notify(), notifyAll()

  • wait():让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”,当前线程被唤醒(进入“就绪状态”)。
  • wait(long timeout):让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)。
  • notify():唤醒在此对象监视器上等待的单个线程
  • notifyAll():唤醒在此对象监视器上等待的所有线程

notify()是依据什么唤醒等待线程的?或者说,wait()等待线程和notify()之间是通过什么关联起来的?

答案是:依据“对象的同步锁”。

多线程循环打印 ABC

思路:考察多线程间通信。首先需要一个线程共有的变量,来标识打印的状态。在 run 方法中,首先获取一个公共的对象,相当于是把「多线程变成顺序执行」,如果获取锁后,并不是需要打印的状态,就释放锁,进入等待;其它线程会得到锁,然后判断,如果是打印状态,就打印,然后通知所有线程,并释放锁。

代码语言:javascript
复制
public class PrintABC {
    private static final int PRINT_A = 0;
    private static final int PRINT_B = 1;
    private static final int PRINT_C = 2;
    
    private static class MyThread extends Thread {
        int which; // 0:打印A;1:打印B;2:打印C
        static volatile int state; // 线程共有,判断所有的打印状态
        static final Object t = new Object();
        
        public MyThread(int which) {
            this.which = which;
        }
        
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (t) {
                    while (state % 3 != which) {
                        try {
                            t.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.print(toABC(which)); // 执行到这里,表明满足条件,打印
                    state++;
                    t.notifyAll(); // 调用notifyAll方法
                }
            }
        }
    }
    
    public static void main(String[] args) {
        new MyThread(PRINT_A).start();
        new MyThread(PRINT_B).start();
        new MyThread(PRINT_C).start();
    }
    private static char toABC(int which) {
        return (char) ('A' + which);
    }
}

yield

不会释放锁

sleep

让当前线程休眠,由“运行状态”→“阻塞状态”。并不会释放任何锁,到时间后线程会进入“就绪状态”。

测试代码

代码语言:javascript
复制
// SleepLockTest.java的源码
public class SleepLockTest{ 
    private static Object obj = new Object();
    public static void main(String[] args){ 
        ThreadA t1 = new ThreadA("t1"); 
        ThreadA t2 = new ThreadA("t2"); 
        t1.start(); 
        t2.start();
    } 
    static class ThreadA extends Thread{
        public ThreadA(String name){ 
            super(name); 
        } 
        public void run(){ 
            // 获取obj对象的同步锁
            synchronized (obj) {
                try {
                    for(int i=0; i <10; i++){ 
                        System.out.printf("%s: %d\n", this.getName(), i); 
                        // i能被4整除时,休眠100毫秒
                        if (i%4 == 0)
                            Thread.sleep(100);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } 
    } 
}

输出的结果(t1 和 t2 的顺序不定,但是必定是同时执行0~9,因为 sleep 并没有释放锁):

代码语言:javascript
复制
t1: 0
t1: 1
t1: 2
t1: 3
t1: 4
t1: 5
t1: 6
t1: 7
t1: 8
t1: 9
t2: 0
t2: 1
t2: 2
t2: 3
t2: 4
t2: 5
t2: 6
t2: 7
t2: 8
t2: 9

join

作用

让“主线程”等待“子线程”结束之后才能继续运行。

代码语言:javascript
复制
// 主线程
public class Father extends Thread {
    public void run() {
        Son s = new Son();
        s.start();
        s.join();
        ...
    }
}
// 子线程
public class Son extends Thread {
    public void run() {
        ...
    }
}

在上述代码中,是 Father 线程,在 son 子线程运行结束后,再继续运行。

源码

代码语言:javascript
复制
public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (millis == 0) {
        while (isAlive()) { // isAlive() 通过子线程调用,则判断的就是子线程
            wait(0); // 等待的是当前线程(CPU 正则运行的线程),而不是子线程!
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

测试代码

代码语言:javascript
复制
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread start ...");
        for (int i = 0; i < 1000000; i++) {
            
        }
        System.out.println("MyThread end ...");
    }
}

@Test
public void testJoin() throws InterruptedException {
    Thread thread = new MyThread();
    thread.start();
    thread.join();
    System.out.println("testJoin end ...");
}

输出:

代码语言:javascript
复制
MyThread start ...
MyThread end ...
testJoin end ...

我们可以看到,调用了 join() 后,主线程输出的testJoin end ...是在MyThread end ...之后,这是因为main线程等待thread线程执行结束后,才继续执行。

问题:为什么在main中调用的thread.join(),却是main线程等待?

虽然是调用子线程的wait()方法,但是它是通过“主线程”去调用的;所以,休眠的是主线程,而不是“子线程”!

wait() 源码的注释:Causes the current thread to wait

用户线程 守护线程

  • 用户线程:用户执行用户级任务
  • 守护线程:“后台线程”,一般用来执行后台任务。

需要注意的是:Java虚拟机在“用户线程”都结束后会后退出。

问题:main() 方法,是守护线程?

答案:不是。main()方法启动的是非守护线程,如果只有这个线程,在mian()的最后一行代码,JVM 会退出(因为所有非守护进程都死了)。

验证代码:

代码语言:javascript
复制
public static void main(String[] args){ 
    System.out.println(Thread.currentThread().getName());
    System.out.println(Thread.currentThread().isDaemon());
} 

输出:

代码语言:javascript
复制
main
false

JVM终止运行条件

当Java虚拟机启动时,通常有一个单一的非守护线程(该线程通过是通过main()方法启动)。JVM会一直运行直到下面的任意一个条件发生,JVM就会终止运行:

  1. 调用了exit()方法,并且exit()有权限被正常执行。
  2. 所有的“非守护线程”都死了(即JVM中仅仅只有“守护线程”)。
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2017.08.07 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 说明
  • 实现多线程的两种方式
    • 优先使用 Runnable
    • start() 和 run()的区别说明
      • 测试代码
        • start 源码
          • run 源码
          • wait(), notify(), notifyAll()
            • notify()是依据什么唤醒等待线程的?或者说,wait()等待线程和notify()之间是通过什么关联起来的?
              • 多线程循环打印 ABC
              • yield
              • sleep
                • 测试代码
                • join
                  • 作用
                    • 源码
                      • 测试代码
                        • 问题:为什么在main中调用的thread.join(),却是main线程等待?
                    • 用户线程 守护线程
                      • 问题:main() 方法,是守护线程?
                        • JVM终止运行条件
                        领券
                        问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档