Java并发编程基础线程

（一）线程简介

线程是操作系统调度的最小单元，每个线程都拥有自己的计算器、堆栈和局部变量等属性，并且能够访问共享的内存变量。为什么要使用多线程可以参考Java多线程及线程池简介。
线程优先级：虽然java线程调度是系统自动完成的，但是我们还是建议系统给某些线程多分配一点执行时间，这个可以通过线程优先级来完成。如果我们的程序想干预线程的调度过程，最简单的办法就是给每个线程设定一个优先级。线程优先级并不是太靠谱，原因是java线程是通过映射到系统的原生线程上来实现的，所以线程调度最重还是取决于操作系统，虽然很多操作系统都提供线程优先级概念，但是并不见得能与java线程优先级一一对应。
线程状态：Java线程状态如下图所示：

Java线程状态.JPG

Java线程状态变迁如下图所示：
Java线程状态变迁.JPG

线程在创建之后，调用 start 方法开始运行。当线程执行 wait 方法之后，线程进入等待状态。进入等待状态的线程需要依靠其他线程的通知才能返回运行状态，而超时等待状态相当于等待状态的基础上增加了超时限制，也就是超时时间到达时将会返回到运行状态。当线程调用同步方法时，在没有获取锁的情况下，线程将会进入阻塞状态。线程在执行 Runnable 的 run 方法之后将会进入到终止状态。注意：Java 将操作系统中的运行和就绪两种状态合并为运行状态。阻塞状态是线程阻塞在进入synchronized 关键字修饰的方法或代码块时的状态，但是阻塞在 java.concurrent 包中 Lock 接口的线程状态却是等待状态，因为 java.concurrent 包中 Lock 接口对于阻塞的实现均使用了 LockSupport 类中的相关方法。

（二）启动和终止线程

启动线程：通过调用线程的start()方法启动线程，随着run()方法执行完毕，线程也随之终止。在构建线程时，最好为每个线程设置线程名称，这样在进行问题排查时，可以知道是那个线程出问题了，自定义线程最好能够起个名字，如AsyncTask源码中线程工厂中创建新线程的时候都会给线程起一个“AsyncTask #mCount”的名字，其中mCount就是我们在Java并发机制的底层实现讲到的原子操作类，原子操作类在并发操作的时候是线程安全的，原子操作类是基于CAS来实现。

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

理解中断：中断可以理解为线程的一个标志位属性，它标识一个运行中的线程是否被其它线程进行了中断操作。中断好比其他线程对该线程打了招呼，其它线程通过调用该线程的interrupt（）方法对其进行中断操作。
过期的suspend（）、resume（）和stop（）操作：如果把播放音乐比作一个线程的运行，那么对音乐播放做出的暂停、恢复和停止操作对应在线程Thread的API就是suspend（）、resume（）和stop（）。不建议使用的原因：suspend（）方法调用后，线程不会释放已经占有的资源（比如锁），而是占着资源进入睡眠状态，这样容易引起死锁。同样，stop（）方法在终结一个线程时不会保证线程的资源正常释放，通常没有给予线程完成资源释放的工作机会，因此会导致程序可能工作在不确定的状态下。目前暂停和恢复操作用等待/通知机制来替代。
安全的终止线程：中断是线程的一个标识位，而中断操作是一种简单的线程交互方式，而这种交互方式最适合用来取消或者停止任务，而除了中断以外，还可以利用一个boolean变量来控制是否需要停止任务并终止该线程。还有就是run方法执行完毕之后线程也就终止了。安全终止线程的三种方法：1.run方法运行完毕；2.使用中断标志终止线程；3.使用一个boolean变量来终止线程。示例代码及日志如下：

    private void stopThreadTest(){
        try {
            Thread thread = new Thread(new Runner(),"TestThread1");
            thread.start();
            Thread.sleep(100);
            thread.interrupt();
            Runner runner = new Runner();
            Thread thread1 = new Thread(runner,"TestThread2");
            thread1.start();
            Thread.sleep(100);
            runner.cancelThread();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static class Runner implements Runnable{
        private int i;
        private volatile  boolean on = true;
        @Override
        public void run() {
            Log.d("StopThread", "threadName:" + Thread.currentThread().getName() + " start");
            while (on && !Thread.interrupted()){
                i++;
            }
            //打印对应的线程名称
            Log.d("StopThread", "threadName:" + Thread.currentThread().getName() + " end");
        }

        public void cancelThread(){
            on = false;
        }
    }
打印日志：
10:47:08.018 21231-21359/ D/StopThread: threadName:TestThread1 start
10:47:08.118 21231-21359/ D/StopThread: threadName:TestThread1 end
10:47:08.118 21231-21360/ D/StopThread: threadName:TestThread2 start
10:47:08.218 21231-21360/ D/StopThread: threadName:TestThread2 end

主线程通过中断操作或者cancel（）方法均可使线程终止，这种通过标志位或者中断操作的方法能够使线程在终止时有机会去清理资源，而不是武断的将线程终止，因此这种终止线程的做法更加安全和优雅。

（三）线程间通信

1.volatile 和 synchronized 关键字

volatile 与 synchronized 保证可见性，可见性如果用内存模型来阐述，那就是在变量的写的时候，把把该变量同步到主内存，其他线程通过嗅探主内存的该变量值是否变化，在变化的时候更新自己的工作内存，这样就完成了线程之间的交互。

2.等待/通知机制

应用场景：一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行响应的操作，这个过程开始于一个线程，而最终执行又是另一个线程。这种模式隔离了做什么和怎么做，在功能成眠实现了解耦，Java通过内置的等待/通知机制为这种场景提供了很好的解决方案。等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类 java.lang.Object上，方法和描述如下图所示：


等待通知相关方法.JPG

等待 / 通知机制，是指一个线程 A 调用了对象 O 的 wait 方法进入等待状态，而另外一个线程 B 调用了对象 O 的 notify 或者 notifyAll 方法，线程 A 收到通知后从对象 O 的 wait 方法返回，进而执行后续操作。上诉两个线程通过对象 O 完成交互，而对象上的 wait 方法和notify / notifyAll 的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。使用示例如下：

    static boolean flag = true;
    static Object lock = new Object();
    private static final String TAGT = "WaitNotifyTest";
    private static final int SLEEP_TIME = 1000;
    private void testWaitNotify(){
        try {
            Thread waitThread = new Thread(new WaitRunner(),"WaitThread");
            waitThread.start();
            Thread.sleep(SLEEP_TIME);
            Thread notifyThread = new Thread(new NotifyRunner(),"NotifyThread");
            notifyThread.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class WaitRunner implements Runnable{
        @Override
        public void run() {
            //First:WaitThread get monitor
            synchronized (lock){
                while (flag){
                    Log.d(TAGT, "threadName:" + Thread.currentThread().getName() + "- call object.wait()");
                    try {
                        //Second: object.wait & release monitor
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //Third: util other thread call lock,notify,WaitThread do something when condition satisfied
                if(!flag){
                    Log.d(TAGT, "WaitThread do something");
                }
            }
        }
    }

    static class NotifyRunner implements Runnable{
        @Override
        public void run() {
            try {
                //First: NotifyThread get monitor
                synchronized (lock){
                    //Second : object.notify(),notify() do not release monitor until this method complete
                    Log.d(TAGT, "theadName: " + Thread.currentThread().getName() + "- call object.notify()");
                    lock.notifyAll();
                    flag = false;
                    Thread.sleep(SLEEP_TIME);
                }

                synchronized (lock){
                    Thread.sleep(SLEEP_TIME);
                    Log.d(TAGT, "theadName: " + Thread.currentThread().getName() + "- notifyThread end");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    } 

打印日志如下： 
D/WaitNotifyTest: threadName:WaitThread- call object.wait()
D/WaitNotifyTest: theadName: NotifyThread- call object.notify()
D/WaitNotifyTest: theadName: NotifyThread- notifyThread end
D/WaitNotifyTest: WaitThread do something

在使用以上方法需要注意几点：
（1）使用 wait、notify、notifyAll 时需要先对调用对象加锁
（2）调用 wait 方法后，线程状态由 RUNNING 变为 WAITING，并将当前线程放置到对象的等待队列
（3）notify 或 notifyAll 方法调用之后，等待线程依旧不会从 wait 返回，需要调用 notify 或 notifyAll 的线程释放锁之后，等待线程才有机会从 wait 方法
（4）notify 方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而 notifyAll 方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由 WAITING 变为 BLOCKED
（5）从 wait 方法返回的前提是获得了调用对象的锁
下图描述了上述示例

WaitNotify运行过程.JPG

从上图可知，WaitThread首先获取对象的锁，然后调用对象的wait（）方法，从而放弃了锁并进入对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notify（）方法，将WaitThread从WaitQueue移到SynchronizedQueue中，此时WaitThread的状态变为阻塞状态，NotifyThread释放锁之后，WaitThread再次获取到锁并从wait（）方法返回继续执行。
等待/通知经典范式
该范式分为两部分，分别针对等待放（消费者）和通知方（生产者）
等待方遵循如下原则：
（1）获取对象的锁；
（2）如果条件不满足，那么调用对象的wait（）方法，被通知后仍要检查条件。
（3）条件满足则执行对应的逻辑。
对应伪代码如下：
sychronized(对象){
while（条件不满足）{
对象.wait();
}
对应的处理逻辑
}
通知方遵循的如下原则：
（1）获取对象的锁；
（2）改变条件；
（3）通知所有等待在对象上的线程；
对应伪代码如下：
sychronized(对象){
改变条件
对象.notifyAll();
}

3.管道输入/ 输出流

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

public class PipedDemo {
    public static void main(String[] args) throws IOException {
        PipedReader pipedReader = new PipedReader();
        PipedWriter pipedWriter = new PipedWriter();
        //将输入输出流进行链接，否则会抛出 IOException
        pipedWriter.connect(pipedReader);
        Thread printThread = new Thread(new PrintRunnable(pipedReader));
        printThread.start();
        int receive = 0;
        try {
            while ((receive = System.in.read()) != -1) {
                pipedWriter.write(receive);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            pipedWriter.close();
        }
    }

    static class PrintRunnable implements Runnable {
        private PipedReader pipedReader;

        public PrintRunnable(PipedReader pipedReader) {
            this.pipedReader = pipedReader;
        }

        @Override
        public void run() {
            int receive = 0;
            try {
                while ((receive = pipedReader.read()) != -1) {
                    System.out.println("输出：" + (char) receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
/**
 * Demo
 * 输出：D
 * 输出：e
 * 输出：m
 * 输出：o
 * 输出
 */
4.Thread.join() 的使用

如果一个线程 A 执行了 thread.join() 语句，其含义是：当前线程 A 等待 thread 线程终止之后才从 thread.join() 返回。线程 Thread 除了提供 join 方法之外，还提供了 join(long millis)等两个具备超时特性的方法。这两个超时方法表示，如果线程 thread 在给定的超时时间里没有终止，那么将会从该超时方法中返回。

public class JoinDemo {
    public static void main(String[] args) {
        Thread previous = Thread.currentThread();
        for (int i = 0; i < 10; i++) {
            //每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
            Thread thread=new Thread(new MyRunnable(previous),String.valueOf(i));
            thread.start();
            previous=thread;
        }
    }

    static class MyRunnable implements Runnable{
        private Thread thread;

        public MyRunnable(Thread thread) {
            this.thread = thread;
        }

        @Override
        public void run() {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" terminate ");
        }
    }
}
    /**输出：
     * 0 terminate 
     * 1 terminate 
     * 2 terminate 
     * 3 terminate 
     * 4 terminate 
     * 5 terminate 
     * 6 terminate 
     * 7 terminate 
     * 8 terminate 
     * 9 terminate
     */

从输出可以看出，每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从 join 方法返回，这里涉及了等待 / 通知机制（等待前驱线程结束，接受前驱线程结束的通知）。当线程终止时，会调用线程自身的 notifyAll 方法，会通知所有等待在该线程对象上的线程。

参考资料

《Java并发编程的艺术》
《深入理解JVM》

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,602评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,442评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,878评论 0赞 344
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,306评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,330评论 5赞 373
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,071评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,382评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,006评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,512评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,965评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,094评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,732评论 4赞 323
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,283评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,286评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,512评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,536评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,828评论 2赞 345

推荐阅读更多精彩内容

  • Java并发编程基础-线程间通信
    章节目录 volatile 与 synchronized 关键字 等待/通知机制 等待/通知经典范式 管道输入/输...
    markfork阅读 335评论 0赞 3
  • Java基础——有点闹的线程和进程
    一、进程和线程 进程 进程就是一个执行中的程序实例，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程。...
    阿敏其人阅读 2,609评论 0赞 13
  • Java多线程学习
    Java多线程学习 [-] 一扩展javalangThread类 二实现javalangRunnable接口 三T...
    影驰阅读 2,952评论 1赞 18
  • Java 线程基础
    📦 本文以及示例源码已归档在 javacore 一、线程简介什么是进程什么是线程进程和线程的区别 二、线程基本用法...
    静默虚空阅读 259评论 0赞 1
  • The moon and sixpence Day 14
    Stroeve看到strickland画的妻子的裸体，从开始的愤怒变成崇拜，后来居然邀请strickland一起回...
    milaji阅读 76评论 0赞 0