[TOC]

声明

该系列文章只是记录本人回顾java多线程编程时候记录的笔记。文中所用语言并非严谨的专业术语(太严谨的术语其实本人也不会……)。难免有理解偏差的地方，欢迎指正。
另外，大神请绕路。不喜勿喷。
毕竟好记性不如烂笔头嘛，而且许多东西只要不是你经常用的最终都会一丢丢一丢丢地给忘记。

1 线程的相关概念

1.1 线程状态

先看看下面这张来自百度的java线程状态图：

线程状态图

新建状态（New）

用new语句创建的线程处于新建状态，只是为他分配了内存，并没有开始运行。

就绪状态（Runnable）

调用start()方法，线程就进入就绪状态。
然而也仅仅是处于可运行状态，到底能不能立即运行还要看操作系统的调度。

运行状态（Running）

此时是真正的处于运行状态。是由可运行状态到运行状态。

阻塞状态（Blocked）

线程由于某些原因放弃CPU的占有权。当线程处于阻塞状态时。直到下次该线程处于可运行状态时才有可能再次进入运行状态。

可能的阻塞原因：

- 调用了wait方法，进入了等待池。
- 等待某些资源可用。
- I/O等待、调用了sleep方法、其他线程的join方法等。

死亡状态（Dead）

线程执行结束。注意一个已经死亡的线程是没办法“复活”的。只能重新new一个。

1.2 优先级

大多数资料都显示，java中的线程优先级并不会生效，往往会被操作系统直接忽略。
所以，此处对这部分内容直接略过。

1.3 daemon线程

daemon线程又称为后台线程或精灵线程。

可以通过setDaemon(boolean isDeamon)将一个线程设置为后台线程。比如java的垃圾回收线程。

注意：

当JVM中不存在非daemon线程的时候，JVM就会退出。
将一个线程设置为Daemon线程，必须在其启动之前进行设置。

1.4 中断

java线程的中断表示的是：某个线程是否被其他线程中断过。相当于一个boolean类型的标识位。
此处的中断过类似于你正在写代码，突然有人找你说话，此处可以理解为被中断了。

isInterrupted():是否被中断(如果线程已经结束了,也会返回false)
Thread.interrupted():复位中断标志

线程被中断后抛出java.lang.InterruptedException异常，但是在异常被抛出之前，JVM会先将中断标识位复位。也就是说，在抛出java.lang.InterruptedException异常之后并且在下次中断之前调用isInterrupted()方法会返回false。

1.5 suspend resume stop

这三个API都是deprecated的。已经被废弃。此处提出来只是为了知识点的完整性。

suspend():暂停(睡眠)线程
resume():恢复线程
stop():终止线程

在《java并发编程的艺术》一书中，作者举了个很形象的例子来说明这三个方法的作用:CD机播放音乐时暂停(suspend)、恢复(resume)和停止(stop)的操作。同时，作者也说明了这三个人性化的方法之所以过时是因为:

suspend方法会一致占有着拥有的资源进入睡眠状态
stop方法在终止的线程的时候对资源的释放没有保证

1.6 对象监视器

任何对象都有自己的监视器。当某个对象被同步方法或者同步块调用时，执行方法的线程必须先获得其监视器。
没有获取到监视器的线程将被阻塞在方法的入口处进入阻塞(blocked)状态。

所以，任何对象都可以被当做锁来使用。

1.7 wait()和sleep()

两者都可以让线程等待
wait()调用时,必须先获取到锁
wait()是Object的方法
sleep()是Thread的方法

2 线程通信

一般而言，线程通信至少有两种方式：消息传递和共享内存。

在java里一般是共享内存实现的线程通信。当然也有第三方的消息传递模型的线程通信。
下文所说的线程通信指的是共享内存模型。

2.1 基本概念

和线程通信相关的方法

method	DESC
notify()	通知一个在对象上等待的线程，使其从wait()方法返回,返回的前提是该线程获取到了对象的锁
notifyAll()	通知所有等待在该对象上的线程
wait()	调用wait方法的线程将释放锁(如果已经持有锁的话)并进入waiting状态。只有等待其他线程的通知或被中断才会返回。
wait(long t)	和wait方法的不同是：等待t毫秒还是没有被唤醒的话会“超时返回”
wait(long,int)	对超时时间控制更加细致的wait(long)版本
join()	线程T调用tx.join()的意思是:T等待tx线程结束后才从tx.join()返回,接着执行T自己的后续代码

几个注意点

调用wait、notify、notifyAll时必须先获得锁
调用wait方法后，线程有running状态-->waitting状态，并将当前线程至于对象的等待池中。
调用notify或者notifyAll方法后waiting状态的线程能够返回的前提是：调用notifyAll或notify方法的线程先释放锁，并且该线程获得了锁。
notify调用后，会将等待池(等待队列)中的一个线程移动到同步队列中。被移动的线程状态:waiting-->blocked。
notifyAll方法调用后，会将等待池中所有的线程移动至同步队列中。被移动的线程状态:waiting-->blocked。

join()的一个有趣的例子

** 注意：该示例来自《java并发编程的艺术》一书**

import java.util.concurrent.TimeUnit;

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

        TimeUnit.SECONDS.sleep(5);
        System.out.println(Thread.currentThread().getName() + " terminate.");
    }

    static class Runner implements Runnable {
        private Thread previous;

        public Runner(Thread thread) {
            this.previous = thread;
        }

        public void run() {
            try {
                previous.join();
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread().getName() + " terminate.");
        }
    }
}

以上示例的结果其实就是所有线程依次串行执行。

2.2 线程同步示例

此处是本人改写的一个生产者和消费者的案例。

生产者不断生成，消费者不断消费。

public class ProducerConsumer {

    public static void main(String[] args) {
        Container container = new Container(5);
        for (int i = 0; i < 10; i++) {
            new Thread(new Producer(container), "P-" + i).start();
            new Thread(new Consumer(container), "C-" + i).start();
        }
    }

    public static class Product {
        private String name;

        public Product(String name) {
            super();
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "[name=" + name + "]";
        }

    }

    public static class Container {
        private int nextIndex = 0;
        Product[] products = null;

        public Container(int size) {
            this.products = new Product[size > 0 ? size : 5];
        }

        public void push(Product product) {
            synchronized (products) {
                while (this.nextIndex >= this.products.length) {
                    try {
                        // 访问products的线程先wait
                        this.products.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 叫醒在products等待池上等待的线程
                this.products.notifyAll();
                this.products[nextIndex++] = product;
            }
        }

        public Product pop() {
            synchronized (products) {
                while (this.nextIndex <= 0) {
                    try {
                        this.products.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 叫醒在products等待池上等待的线程
                this.products.notifyAll();
                return this.products[--nextIndex];
            }
        }
    }

    public static class Producer implements Runnable {

        private Container container;

        public Producer(Container container) {
            super();
            this.container = container;
        }

        @Override
        public void run() {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                Product p = new Product(Thread.currentThread().getName() + "_" + i);
                this.container.push(p);
                System.out.println("生产者[" + Thread.currentThread().getName() + "]生产>>>>>>:" + p);
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static class Consumer implements Runnable {

        private Container container;

        public Consumer(Container container) {
            super();
            this.container = container;
        }

        @Override
        public void run() {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                Product product = this.container.pop();
                System.out.println("消费者[" + Thread.currentThread().getName() + "]消费<<<<<<:" + product);
                try {
                    Thread.sleep((long) (Math.random() * 2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

参考资料

《java并发编程的艺术》

java多线程-02-基本操作及线程通信示例