多线程

一、多线程

1.1 并发与并行

• 并发：指两个或多个事件在同一时间段内发生。

并发.png

• 并行：指两个或多个事件在同一时刻发生（同时发生）。

并行.png

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这个情况称之为线程调度。

1.2 线程与进程

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程调度

• 分时调度

  所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。

• 抢占式调度

  优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度。

多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

二、线程

2.1 Thread类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

构造方法

• public Thread():分配一个新的线程对象。

• public Thread(String name):分配一个指定名字的新的线程对象。

• public Thread(Runnable target):分配一个带有指定目标新的线程对象。

• public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法

• public String getName():获取当前线程名称。
• public final void setName():改变线程名称，使之与参数name相同。
• public final void setPriority(int priority):更改线程的优先级。
• public void start():导致此线程开始执行；Java虚拟机调用此线程的run方法。
• public void run():此线程要执行的任务在此处定义代码。
• public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂停停止执行）。
• public static Thread currentThread():返回对当前正在执行的线程对象的引用。
• public void interrupt():中断线程
• public final boolean isAlive():测试线程是否处于活动状态。

创建线程的方式总共有两种，一种是继承Thread类方式，另一种是实现Runnable接口方式。

2.2 创建线程方式一（继承Thread类）

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

Java中通过继承Thread类来创建并启动多线程的步骤如下：

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。

2. 创建Thread子类的实例，即创建了线程对象

3. 调用线程对象的start()方法来启动该线程

创建线程类的示例代码如下：

/**
 * 调用Thread类中的start方法，开启新的线程，执行run方法
 * void start()使该线程开始执行;JavaJVM调用该线程的run()
 * 结果是两个线程并发地运行;当前线程(main线程)和另一个线程(创建的新线程，执行其run方法)
 * 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
 * Java程序属于抢占式调度，哪个线程优先执行;同一个优先级，随机选择一个执行
 */
public class TestThread {
    public static void main(String[] args) {
        //创建自定义线程对象
        MyThread my = new MyThread();
        //开启新线程
        my.start();
        //在主方法中执行for循环  
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程！"+i);
        }
    }
}

public class MyThread extends Thread{
    //继承Thread类，重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {               
            System.out.println(Thread.currentThread().getName()+" sey:hello");
        }       
    }
}

2.3 创建线程方式二（实现Runnable接口）

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。

代码如下：

public class TestRunnable {
    public static void main(String[] args) {
        //创建一个Runnable接口的实现类对象
        MyRunnable mr = new MyRunnable();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread thread = new Thread(mr,"线程的名字");
        //开启线程
        thread.start();
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }       
    }
}

2.4 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runnable接口的话，则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类。

扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实就是在操作系统中启动了一个进程。

2.5 匿名内部类方式实现线程的创建

使用线程的匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，重写Runnable接口中的run方法：

public static void main(String[] args) {
    /**
     * 线程的父类是Thread
     * new Thread(){}.start();
     */
    new Thread(){
        //重写run方法
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
        }
    }.start();
        
    /**
     * 线程的接口Runnable
     * Runnable r = new RunnableImpl(); //多态
     */
    Runnable r = new Runnable() {
        //重写run方法
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName()+" "+i);
            }               
        }
    };
    new Thread(r).start();
        
    /**
     * 简化接口的方式
     */
    new Thread(new Runnable() {
        //重写run方法
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName()+" "+i);
            }               
        }
    }).start();
}

三、线程安全

3.1 线程安全

如果有多个线程在同时运行，而这些线程可能同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

模拟买票案例：

public class RunnableImpl implements Runnable{
    //总共100张票
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+"卖出第"+(101-ticket)+"张票");
                ticket--;
            }else {
                break;
            }
        }               
    }   
}

/**
 * 模拟卖票案例
 * 创建3个线程，同时开启，对共享的票进行出售
 */
public static void main(String[] args) {
    RunnableImpl runnableImpl = new RunnableImpl();
    Thread t1 = new Thread(runnableImpl,"窗口一");
    Thread t2 = new Thread(runnableImpl,"窗口二");
    Thread t3 = new Thread(runnableImpl,"窗口三");
    t1.start();
    t2.start();
    t3.start();
}

3.2 线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。

根据案例简述：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等待，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作，java引入了线程同步机制。

有三种方式完成同步操作：

1. 同步代码块。
2. 同步方法。
3. Lock锁机制。

3.3 同步代码块

• 同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式：

synchronized(同步锁){
    需要同步操作的代码
}

同步锁：

对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。

1. 锁对象 可以是任意类型。
2. 多个线程对象 要使用用一把锁。

注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等候（BLOCKED）。

使用同步代码块解决代码：

/**
 * 解决线程安全问题的第一种方案：使用同步代码块
 * 格式：
 *  synchronized(锁对象){
 *      可能会出现线程安全问题的代码（访问了共享数据的代码）
 *  }
 * 注意：
 *  1.通过代码块中的锁对象，可以使用任意的对象
 *  2.但是必须保证多个线程使用的锁对象是同一个
 *  3.锁对象作用：
 *      把同步代码块锁住，只让一个线程在同步代码块中执行
 */
public class RunnableImpl implements Runnable{
    private int ticket = 100;
    //创建一个锁对象
    Object obj = new Object();
    @Override
    public void run() {
        while(true){
            //同步代码块
            synchronized (obj) {
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName()+"卖出第"+(101-ticket)+"张票");
                    ticket--;
                }else {
                    break;
                }
            }
        }               
    }   
}

3.4 同步方法

• 同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

格式：

public synchronized void method(){
    可能会产生线程安全问题的代码
}

同步锁是谁？
对于非static方法，同步锁就是this。
对于static方法，我们使用当前方法所在类的字节码对象（类名.class）。

使用同步方法代码如下：

/**
 * 解决线程安全问题的第二种方案：使用同步方法
 * 使用步骤：
 *  1.把访问了共享数据的代码抽取出来，放到一个方法中
 *  2.在方法上添加synchronized修饰符
 * 格式：定义方法的格式
 * 修饰符 synchronized 返回值类型 方法名(参数列表){
 *  可能会出现线程安全问题的代码（访问了共享数据的代码）
 * }
 */
public class RunnableImpl implements Runnable{
    private int ticket = 100;
    //创建一个锁对象   
    @Override
    public void run() {
        while(true) {
            payTicket();
        }       
    }
    /**
     * 定义一个同步方法
     * 同步方法也会把方法内部的代码锁住
     * 只让一个线程执行
     * 同步方法的锁对象是谁？
     * 就是实现类对象 new RunnableImpl()
     * 也就是this
     */
    public synchronized void payTicket(){
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName()+"卖出第"+(101-ticket)+"张票");
            ticket--;
        }
    }
}

对于static的同步方法：

public class RunnableImpl implements Runnable{
    private int ticket = 100;
    //创建一个锁对象   
    @Override
    public void run() {
        while(true) {
            payTicket();
        }       
    }
    /**
     * 静态的同步方法
     * 锁对象是谁？
     * 不能是this
     * this是创建对象之后产生的，静态方法优先于对象
     * 静态方法的锁对象是本类的class属性-->class文件对象（反射）
     */
    public synchronized void payTicket(){
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName()+"卖出第"+(101-ticket)+"张票");
            ticket--;
        }
    }
}

3.5 Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。

Lock锁也称为同步锁，加锁与释放锁方法，如下：

• public void lock():加同步锁。
• public void unlock():释放同步锁。

使用如下：

/**
 * 解决线程安全问题的第三种方案：使用Lock锁
 * java.util.concurrent.locks.Lock接口
 * Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
 * Lock接口中的方法：
 *      void lock()获取锁。
 *      void unlock()释放锁。
 * java.util.concurrent.locks.ReentrantLock implements Lock接口
 * 
 * 使用步骤：
 *  1.在成员位置创建一个ReentrantLock对象
 *  2.在可能会出现安全问题的代码前调用Lock接口中的方法lock()获取锁
 *  3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock()释放锁
 */
public class Ticket implements Runnable{
    private int ticket = 100;
    
    //1.在成员位置创建一个ReentrantLock对象
    Lock lock = new ReentrantLock();
    @Override
    public void run() {     
        while(true) {
            //2.调用lock()获取锁
            lock.lock();
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+"卖出第"+(101-ticket)+"张票");
                ticket--;
            }
            //3.调用unlock()释放锁
            lock.unlock();
        }   
    }
}

四、线程状态

4.1 线程状态概述

当线程被创建并启动以后，它既不是一启动就进入执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中java.lang.Thread.State这个枚举中给出了六种线程状态：

• NEW(初始)：线程刚被创建，但是并未启动，但还没有调用start()方法。

• RUNNABLE(运行)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
  线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

• BLOCKED(锁阻塞)：当一个线程视图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将进入Runnable状态。

• WAITING(无限等待)：一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。

• TIMED_WAITING(计时等待)：同waiting状态，有几个方法有超时参数，调用他们将进入Timed_Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep、Object.wait。

• TERMINATED(结束)：因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

线程的状态图

线程的状态图.jpg

4.2 Timed_Waiting（计时等待）

Timed_Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。当我们调用了sleep方法之后，当前执行的线程就进入"休眠状态"，其实就是所谓的Timed_Waiting（计时等待）。

案例：实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串

public class MyThread extends Thread{
    public void run() {
        for (int i = 0; i < 100; i++) {
            if((i) % 10 == 0){
                System.out.println("-------"+i);
            }
            System.out.println(i);
            try {
                Thread.sleep(1000);
                System.out.println("线程睡眠1秒！");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        new MyThread().start();
    }
}

重要几点：

1. 进入Timed_Waiting状态的一种常见情形是调用sleep方法，单独的线程也可以调用，不一定非要有协作关系。
2. 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠
3. sleep与锁无关，线程睡眠到期自然苏醒，并返回到Runnable（可运行）状态。

小提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行。

Timed_Waiting线程状态图：

timed_waiting.png

4.3 BLOCKED（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。这是由Runnable状态进入Blocked状态。

扩展：除此Waiting以及Time_Waiting状态也会在某种情况下进入阻塞状态。

Blocked线程状态图

Blocked.png

4.4 Waiting（无限等待）

Waiting状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

代码示例：

/**
 * 等待唤醒案例:线程之间的通信
 *   创建一个顾客线程(消费者):顾客告知老板要的包子的种类和数量，调用wait(),放弃cpu的执行,进入到WAITING状态(无限等待)
 *   创建一个老板线程(生产者):花了5秒做包子,做好包子之后，调用notify(),唤醒顾客吃包子
 * 注意:
 *   顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只有一个在执行
 *   同步使用的锁对象必须保持唯一
 *   只有锁对象才能调用wait()和notify()
 * Object类中的方法
 * void wait():在其他线程调用此对象的notify()或notifyAll()方法前，导致当前线程等待。
 * void notify():唤醒在此对象监视器上等待的单个线程。会继续执行wait()方法之后的代码。
 */
public class WaitAndNotify01 {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        /**
         * 创建一个顾客线程(消费者)
         */
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                    synchronized (obj) {
                        System.out.println("顾客告知老板要的包子的种类和数量...");
                        //调用wait(),放弃cpu的执行,进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("顾客拿到包子吃起来");    
                        System.out.println("---------------------------");
                    }
                }   
            };
        }.start();
        /**
         * 创建一个老板线程(生产者)
         */
        new Thread(){
            @Override
            public void run() { 
                while (true) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                    synchronized (obj) {
                        System.out.println("5秒之后做好包子，老板将包子交给顾客");
                        obj.notify();//唤醒一个等待的线程
                    }
                }   
            };
        }.start();
    }
}

4.5 补充Timed_Waiting

代码示例：

/**
 * 进入到Timed_Waiting(计时等待)有两种方式
 * 1.使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
 * 2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，
 *    线程睡醒进入到Runnable/Blocked状态
 * 唤醒的方法：
 *   void notify():唤醒在此对象监视器上等待的单个线程。
 *   void notifyAll():唤醒在此对象监视器上等待的所有线程。
 */
public class WaitAndNotify02 {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        /**
         * 创建第一个顾客线程(消费者)
         */
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    // 保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                    synchronized (obj) {
                        System.out.println("顾客1告知老板要的包子的种类和数量...");
                        // 调用wait(),放弃cpu的执行,进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        // 唤醒之后执行的代码
                        System.out.println("顾客1拿到包子吃起来");
                        System.out.println("---------------------------");
                    }
                }
            };
        }.start();      
        /**
         * 创建第二个顾客线程(消费者)
         */
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    // 保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                    synchronized (obj) {
                        System.out.println("顾客2告知老板要的包子的种类和数量...");
                        // 调用wait(),放弃cpu的执行,进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        // 唤醒之后执行的代码
                        System.out.println("顾客2拿到包子吃起来");
                        System.out.println("---------------------------");
                    }
                }
            };
        }.start();  
        /**
         * 创建一个老板线程(生产者)
         */
        new Thread(){
            @Override
            public void run() { 
                while (true) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                    synchronized (obj) {
                        System.out.println("5秒之后做好包子，老板将包子交给顾客");
                        obj.notifyAll();//唤醒所有等待的线程
                    }
                }   
            };
        }.start();  
    }
}