多线程

1.1 程序和进程

　　程序就是一堆静态的代码，存储在硬盘上，程序如果不运行，其可以看做是一个文件。程序运行就产生进程，进程一直向前运行，直到程序结束，进程也结束。

1.2 操作系统的发展

单任务操作系统：一段时间只能运行一个程序（任务）。cpu利用率非常低。

为了提高计算机cpu的利用率，出现了进程的概念（前面出现了批处理操作系统）：

把一个程序的一次运行产生的进程（内存空间、资源、程序的执行堆栈）在内存上划分出一块空间，并为其分配好资源，只时候只需要CPU调度过来就能够运行起来，有多个程序就有多个进程（内存空间、资源、程序的执行堆栈），用进程来对应一个程序，每个进程对应一定的内存地址空间，并且只能使用它自己的内存空间，各个进程间互不干扰。并且进程保存了程序每个时刻的运行状态，这样就为进程切换提供了可能。当进程暂时时，它会保存当前进程的状态（比如进程标识、进程的使用的资源等），在下一次重新切换回来时，便根据之前保存的状态进行恢复，然后继续执行。

进程作为操作系统分配资源的基本单位。

这就是并发，能够让操作系统从宏观上看起来同一个时间段有多个任务在执行。换句话说，进程让操作系统的并发成为了可能。

注意，虽然并发从宏观上看有多个任务在执行，但是事实上，任一个具体的时刻，只有一个任务在占用CPU资源（当然是对于单核CPU来说的），区别于并行（一个时间段，多个任务同时运行，多个CPU运行各自的任务）。

线程的出现：

在出现了进程之后，操作系统的性能得到了大大的提升。虽然进程的出现解决了操作系统的并发问题，但是人们仍然不满足，人们逐渐对实时性有了要求。因为一个进程在一个时间段内只能做一件事情，如果一个进程有多个子任务，只能逐个地去执行这些子任务。比如对于一个监控系统来说，它不仅要把图像数据显示在画面上，还要与服务端进行通信获取图像数据，还要处理人们的交互操作。如果某一个时刻该系统正在与服务器通信获取图像数据，而用户又在监控系统上点击了某个按钮，那么该系统就要等待获取完图像数据之后才能处理用户的操作，如果获取图像数据需要耗费10s，那么用户就只有一直在等待。显然，对于这样的系统，人们是无法满足的。

　　那么可不可以将这些子任务分开执行呢？即在系统获取图像数据的同时，如果用户点击了某个按钮，则会暂停获取图像数据，而先去响应用户的操作（因为用户的操作往往执行时间很短），在处理完用户操作之后，再继续获取图像数据。人们就发明了线程，让一个线程去执行一个子任务，这样一个进程就包括了多个线程，每个线程负责一个独立的子任务，这样在用户点击按钮的时候，就可以暂停获取图像数据的线程，让UI线程响应用户的操作，响应完之后再切换回来，让获取图像的线程得到CPU资源。从而让用户感觉系统是同时在做多件事情的，满足了用户对实时性的要求。

　　换句话说，进程让操作系统的并发性成为可能，而线程让进程的内部并发成为可能。

　　但是要注意，一个进程虽然包括多个线程，但是这些线程是共同享有进程占有的资源和地址空间的。进程是操作系统进行资源分配的基本单位，而线程是操作系统进行调度的基本单位。

1.3 进程和线程区别

1.4多线程实现

 Thread 类位于java.lang中，表示进程中的执行线程。实现多线程有两种方式

1.4.1 [1] 继承Thread

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("我是多线程MyThread");
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread:" + i);
        }
    }
}


public class Test01 {
    public static void main(String[] args) {

        // main开始运行产生一个进程，该进程默认有个主(main)线程
        // 创建线程
        MyThread t1 = new MyThread();
        // 启动线程
        t1.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main Thread:" + i);
        }

    }
}

main线程和t1线程抢占CPU 执行。多线程在提高CPU利用率的同时，增加程序的复杂度。

1.4.1 [2]实现Runnable接口

public class MyRun implements Runnable {

    @Override
    public void run() {
        System.out.println("我是MyRun");
        for (int i = 0; i < 5; i++) {
            System.out.println("my run:" + i);
        }
    }
}




public class Test02 {
    public static void main(String[] args) {
        
        MyRun run = new MyRun();
        Thread t1 = new Thread(run);
        t1.start();

        // main开始运行产生一个进程，该进程默认有个主(main)线程
        for (int i = 0; i < 5; i++) {
            System.out.println("main Thread:" + i);
        }
    }
}

售票案例

继承Thread和实现Runnable接口实现多线程的优缺点：

【1】继承Thread的线程类不能再继续继承其它类，实现Runnable接口的类还可以继承其他类。

【2】实现runnable接口的线程类，可以让多个线程共享线程实现类的资源。’

总结:

多线程提高了cpu利用率，但程序的复杂度也随之增加。一旦线程开始执行，很难通过其他方式控制线程的轨迹。

多个线程抢占CPU导致线程的运行轨迹不确定。

窗口A抢占到CPU，count=5，执行run

public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            if (count > 0) {
                count--;
                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
            }
        }
    }
窗口B抢占到CPU，count=4，执行run
public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            if (count > 0) {
                count--;
                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
            }
        }
    }
窗口A到抢占CPU，count=3，执行run
public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            if (count > 0) {
                count--; => count=2  窗口A在此挂起。count=>2准备输出的字符串:窗口A卖出一张票，还剩2张

                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
            }
        }
    }
窗口C到抢占CPU，count=2，执行run
public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            if (count > 0) {
                count--; => count=1窗口C挂起，count=1准备输出的字符串:窗口C卖出一张票，还剩1张

                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
            }
        }
    }
窗口B抢占CPU，count=1，从上次挂起的位置开始执行run
public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            if (count > 0) {
                count--;
                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); => count=0
            }//窗口B挂起，count=0

        }
    }
窗口C抢占到CPU，count=0，从上次挂起位置开始执行run
public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            if (count > 0) {
                count--; => count=1
                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
            } //窗口C从此次开始执行，count=1（挂起时）

        }
    }
窗口A抢占到CPU，count=0，从上次挂起的位置开始执行run
public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            if (count > 0) {
                count--; => count=2 
                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
            }//窗口A在此继续执行。count=>2(挂起时)所以显示2张票

        }
    }

结论

【1】多线程抢占CPU执行，CPU可能在任意位置被切换出去（则该线程挂起）；

【2】多线程抢占到CPU后，可以从上次挂起的位置开始执行（要先恢复上次执行的堆栈）

【3】多个线程都可以独立运行，相互不干扰，多个线程都可以访问共享资源，容易造成数据错乱！！！

1.5线程的生命周期

新生状态：

用new关键字建立一个线程后，该线程对象就处于新生状态。

处于新生状态的线程有自己的内存空间，通过调用start（方法）进入就绪状态

就绪状态

处于就绪状态的线程具备了运行的条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU。

当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU调度”。

运行状态

在运行状态的线程执行自己的run方法中的代码，直到等待某资源而阻塞或者执行完代码而死亡。

阻塞状态

处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O资源，将让出CPU并暂时停止自己运行，进入阻塞状态。

在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。

死亡状态

死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个，一个是正常运行

的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过stop方法来终止一个

线程【不推荐使用】；三是线程抛出未捕获的异常。

1.6 线程常用方法

1.6.1 [1]线程优先级

public static void main(String[] args) {
        
        System.out.println(Thread.MIN_PRIORITY);
        System.out.println(Thread.MAX_PRIORITY);
        System.out.println(Thread.NORM_PRIORITY);
        
        //主线程的优先级（默认优先级）
        System.out.println(Thread.currentThread().getPriority());
        
        
        Thread01 t1 = new Thread01();
        // 设置线程的优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        
        
        Thread01 t2 = new Thread01();
        // 设置线程的优先级
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        
        
    }

线程优先级高，被cpu调度的概率大，不表示一定能够先运行。

1.6.1 [2]isAlive

        Thread01 t1 = new Thread01();
        System.out.println(t1.isAlive());
        // 设置线程的优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        System.out.println(t1.isAlive());

线程调用start之后就处于活动状态

1.6.1 [3]join

调用该方法的线程强制执行，其它线程处于阻塞状态，该线程执行完毕后，其它线程再执行

join称为线程的强制执行，有可能被外界中断产生InterruptedException 中断异常。（大领导外出视察，其它人必须停下来让道或者银行取钱VIP会员）

public class Test02 {
    public static void main(String[] args){
        
        Thread02 t = new Thread02("线程A");
        t.start();
        
        for (int i = 0; i < 5; i++) {
            
            if(i == 2) {
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

1.6.1 [4]sleep()

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。休眠的线程进入阻塞状态。

public static void main(String[] args) {
        
        Thread03 t = new Thread03("线程A");
        t.start();
        
        Thread mainThread = Thread.currentThread();
        System.out.println(mainThread.getName()+"即将进入休眠");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 中断线程
        t.interrupt();
        
        System.out.println(mainThread.getName()+"休眠完成");
    }

1.6.1 [5] yield()

public static void main(String[] args) {

        Thread mainThread = Thread.currentThread();

        Thread04 t = new Thread04("线程A");
        t.start();

        
        for (int i = 0; i < 5; i++) {
            if (i == 2) {
                // yield 使当前礼让一次
                Thread.yield();
            }
            System.out.println(mainThread.getName() + "->" + i);
        }
    }

A hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint.

当前线程给cpu调度器一个暗示，暗示其想礼让一次其拥有的cpu，CPU调度者也可以狐狸这次暗示。此时当前线程进入就绪状态。

[6] 线程的终止。

目前而言，不推荐使用stop直接终止线程。用interrupt()方法去中断正在执行的线程，而在线程内部一定要写捕获中断的异常。通过异常处理机制正常结束线程。

1.7线程的安全问题(线程同步)

线程在执行过程中，通过cpu的调度，执行轨迹不确定，对共享资源的访问很容易造成数据的错误。我们称这个错乱称为线程安全问题。

 通常我们都需要保证数据的准确性

1.7.1 同步概念

原子性操作:一个操作要么一次性做完，要么根本不开始，不存在中间状态。

案例:ATM取现操作

 同步就是让操作保持原子性！java提供两种方式实现同步。

1.7.2 同步代码块

把所有的同步操作放到同步代码块中，

synchronized (mutex) {
   // .. .
}

 

mutex 称为互斥锁/同步锁。对共享资源进行加锁实现同步。一般用共享资源作为同步锁，也称同步监视器。

public class MyRun implements Runnable {
    
    // 共享资源
    private int count = 5;

    @Override
    public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            // 同步代码块
            // mutex 互斥锁
            synchronized (this) {
                if (count > 0) {
                    
                    try {
                        Thread.sleep(3000);
                        count--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                    System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
                }
            }
        }
    }
}

总结

synchronized(obj){}中的obj称为同步监视器

同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器

1.7.3 同步方法

public class MyRun implements Runnable {
    
    // 共享资源
    private int count = 5;

    @Override
    public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i < 5; i++) {
            
            this.saleTicket();
            
        }
    }
    
    // 同步方法默认对this加锁
    private synchronized void saleTicket() {
        if (count > 0) {
            
            try {
                Thread.sleep(3000);
                count--;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
        }
    }
}

1.8 死锁(C)

线程t1，拥有A资源，再次申请B资源，线程t2,拥有B资源，再申请A资源，t1因为没有申请到B资源而进入阻塞；t2因为没有申请到A资源进入阻塞。此时两个线程都处于阻塞状态而不能正常结束，而此时cpu空转，这种情况称为死锁。

1.9 线程间通信

当线程在系统内运行时，线程的调度具有一定的透明性，程序通常无法准确控制线程的轮换执行，但java也提供了一些机制来保证线程协调运行

等待/唤醒机制

1，wait(): 让线程处于冻结状态，被wait的线程会被存储到线程池中。

如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态。

2，notify():唤醒线程池中一个线程(任意)。如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。

3，notifyAll():唤醒线程池中的所有线程。如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行。

这些方法都必须定义在同步中。

因为这些方法是用于操作线程状态的方法。

必须要明确到底操作的是哪个锁上的线程。

使用wait方法和使用synchornized来分配cpu时间是有本质区别的。wait会释放锁，synchornized不释放锁。