多线程

1.1 程序和进程

程序就是一堆静态的代码，存储在硬盘上。程序如果不运行，本质就是一个文件。

程序一次运行产生进程，进程一直向前运行，直到进程结束。

1.2 操作系统的发展

单任务操作系统:一段时间只能运行一个程序(任务)。CPU利用率非常低。

引入进程的概念

把程序的一次运行产生进程(内存空间、资源、程序的执行堆栈)

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

多任务操作系统

一台电脑就一个CPU，多个任务轮流使用CPU，从宏观上看，一段时间有多个任务正在运行。

从微观上看，一个时间点只有一个任务在运行。

CPU时间片

多个进程通过CPU时间片轮转实现多任务(进程)。把这种现象叫做并发操作

并行:

一个时间段，多个任务同时进行，多个CPU运行各自的进行。

线程的引入是为了解决实时性问题

线程和进程可以在此网址了解：https://www.cnblogs.com/geeta/p/9474051.html

1.3 进程和线程区别

1.4多线程实现

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

1.1.1 [1] 继承Thread

 1 public class MyThread extends Thread {
 2 
 3     @Override
 4     public void run() {
 5         System.out.println("我是多线程MyThread");
 6         for (int i = 0; i < 5; i++) {
 7             System.out.println("MyThread:" + i);
 8         }
 9     }
10 }
11 
12 public class Test01 {
13     public static void main(String[] args) {
14 
15         // main开始运行产生一个进程，该进程默认有个主(main)线程
16         // 创建线程
17         MyThread t1 = new MyThread();
18         // 启动线程
19         t1.start();
20 
21         for (int i = 0; i < 5; i++) {
22             System.out.println("main Thread:" + i);
23         }
24 
25     }
26 }

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

1.1.2 [2]实现Runnable接口

 1 public class MyRun implements Runnable {
 2 
 3     @Override
 4     public void run() {
 5         System.out.println("我是MyRun");
 6         for (int i = 0; i < 5; i++) {
 7             System.out.println("my run:" + i);
 8         }
 9     }
10 }
11 
12 public class Test02 {
13     public static void main(String[] args) {
14         
15         MyRun run = new MyRun();
16         Thread t1 = new Thread(run);
17         t1.start();
18 
19         // main开始运行产生一个进程，该进程默认有个主(main)线程
20         for (int i = 0; i < 5; i++) {
21             System.out.println("main Thread:" + i);
22         }
23     }
24 }

卖票案例

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

[1] 继承Thread的线程类不能再继承其他类，实现Runnable接口的类还可以继承其他类。

[2] 实现Runnable接口的线程类，可以让多个线程共享线程实现类的资源。

总结:

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

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

2 线程的生命周期

结合生命图理解

新生状态

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

处于新生状态的线程有自己的内存空间(即有资源)，通过调用start()方法进入就绪状态。

就绪状态

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

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

运行状态

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

如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态(位于就绪队列)。

阻塞状态

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

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

死亡状态

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

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

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

3 线程常用方法

【1】线程优先级

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

 1 public static void main(String[] args) {
 2         
 3         System.out.println(Thread.MIN_PRIORITY);
 4         System.out.println(Thread.MAX_PRIORITY);
 5         System.out.println(Thread.NORM_PRIORITY);
 6         
 7         //主线程的优先级（默认优先级）
 8         System.out.println(Thread.currentThread().getPriority());
 9         
10         
11         Thread01 t1 = new Thread01();
12         // 设置线程的优先级
13         t1.setPriority(Thread.MAX_PRIORITY);
14         t1.start();
15         
16         
17         Thread01 t2 = new Thread01();
18         // 设置线程的优先级
19         t2.setPriority(Thread.MIN_PRIORITY);
20         t2.start();
21         
22         
23     }

[2]isAlive

判断线程是否处于活动状态。

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

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

[3]join

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

join称为线程的强制执行，有可能被外界中断产生InterruptedException 中断异常。

 1 public class Test02 {
 2     public static void main(String[] args){
 3         
 4         Thread02 t = new Thread02("线程A");
 5         t.start();
 6         
 7         for (int i = 0; i < 5; i++) {
 8             
 9             if(i == 2) {
10                 try {
11                     t.join();
12                 } catch (InterruptedException e) {
13                     e.printStackTrace();
14                 }
15             }
16             
17             System.out.println(Thread.currentThread().getName() + "->" + i);
18         }
19     }
20 }

[4]sleep()

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

 1 public static void main(String[] args) {
 2         
 3         Thread03 t = new Thread03("线程A");
 4         t.start();
 5         
 6         Thread mainThread = Thread.currentThread();
 7         System.out.println(mainThread.getName()+"即将进入休眠");
 8         try {
 9             Thread.sleep(5000);
10         } catch (InterruptedException e) {
11             e.printStackTrace();
12         }
13         
14         // 中断线程
15         t.interrupt();
16         
17         System.out.println(mainThread.getName()+"休眠完成");
18     }

[5] yield()

如下代码：当i==2时礼让一次，main线程便回到就绪队列当中，等待CPU随机调度

 1 public static void main(String[] args) {
 2 
 3         Thread mainThread = Thread.currentThread();
 4 
 5         Thread04 t = new Thread04("线程A");
 6         t.start();
 7 
 8         
 9         for (int i = 0; i < 5; i++) {
10             if (i == 2) {
11                 // yield 使当前礼让一次
12                 Thread.yield();
13             }
14             System.out.println(mainThread.getName() + "->" + i);
15         }
16     }

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()方法去中断正在执行的线程，而在线程内部一定要写捕获中断的异常。通过异常处理机制正常结束线程。

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

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

4.1 同步概念

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

案例:ATM取现操作

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

4.2 同步代码块

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

1 synchronized (mutex) {
2    // .. .
3 }

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

 1 public class MyRun implements Runnable {
 2     
 3     // 共享资源
 4     private int count = 5;
 5 
 6     @Override
 7     public void run() {
 8         // 模拟一个窗口5个人
 9         for (int i = 0; i < 5; i++) {
10             // 同步代码块
11             // mutex 互斥锁
12             synchronized (this) {
13                 if (count > 0) {
14                     
15                     try {
16                         Thread.sleep(3000);
17                         count--;
18                     } catch (InterruptedException e) {
19                         e.printStackTrace();
20                     }
21                     
22                     System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
23                 }
24             }
25         }
26     }
27 }

总结

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

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

4.3 同步方法

如果同步代码(原子性)很多，可以考虑使用同步方法。

把普通方法用 synchronized 修饰，同步方法的同步监视器是this。

 1 public class MyRun implements Runnable {
 2     
 3     // 共享资源
 4     private int count = 5;
 5 
 6     @Override
 7     public void run() {
 8         // 模拟一个窗口5个人
 9         for (int i = 0; i < 5; i++) {
10             
11             this.saleTicket();
12             
13         }
14     }
15     
16     // 同步方法默认对this加锁
17     private synchronized void saleTicket() {
18         if (count > 0) {
19             
20             try {
21                 Thread.sleep(3000);
22                 count--;
23             } catch (InterruptedException e) {
24                 e.printStackTrace();
25             }
26             
27             System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
28         }
29     }
30 }

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)线程