JavaSE20-线程&同步

1.线程

1.1 基本概念

线程的概念

线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）。

线程&进程

A.多个进程的内部数据和状态都是完全独立的，（进程就是执行中的程序，程序是静态的概念，进程是动态的概念）。而多线程是共享一块内存空间和一组系统资源的，有可能互相影响（多个线程可以在一个进程中）

B.线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小。

多线程编程

在单个程序中可以同时运行多个不同的线程执行不同的任务。但是具体执行哪个线程是由cpu随机决定的。

多线程编程的目的，就是“最大限度地利用CPU资源”，当某一线程的处理不需要占用CPU而只和I/O等资源打交道时，让需要占用CPU资源的其他线程有机会获得CPU资源。

Java中如果我们自己没有产生线程，系统会自动产生一个线程，该线程为主线程 ，main方法就在主线程上运行，我们的程序都是由线程来执行的。

多任务处理被所有的现代操作系统所支持。然而，多任务处理有两种截然不同的类型：基于进程的和基于线程的。

　　基于进程的多任务处理

　　　　（1）基于进程的多任务处理是更熟悉的形式。

　　　　　　　　进程（process）本质上是一个执行的程序。因此基于进程的多任务处理的特点是允许你的计算机同时运行两个或更多的程序。举例来说，基于进程的多任务处理使你在运用文本编辑器的时候可以同时运行java编译器。在基于进程的多任务处理中，程序是调度程序所分派的最小代码单位。

　　　　（2）进程是重量级的任务，需要分配给他们独立的地址空间。进程间通信是昂贵和受限的。进程的转换也是很需要花费的。

　　基于线程的多任务处理

　　　　（1）基于线程的多任务处理环境中，线程是最小的执行单位。这意味着一个程序可以同时执行两个或者多个任务的功能。例如，一个文本编辑器可以在打印的同时格式化文本。

　　　　（2）多线程程序比多进程程序需要更少的代价。多线程是轻量级的任务。它们共享相同的地址空间并且共同分享同一个进程。线程间通信是便宜的，线程间的转换也是低成本的。

　　　　（3）多线程使CPU的利用率提高

1.2 Thread类

构造方法

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

常用方法

方法名	说明
public String getName()	获取当前线程名称。
public void start()	导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run()	此线程要执行的任务在此处定义代码。
public static void sleep(long millis)	使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread()	返回对当前正在执行的线程对象的引用。

1.3 Runnable

步骤如下：

　　1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

　　2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

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

通过实现Runnable接口，使得类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。 而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

1.4 Thread和Runnable的区别

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

总结：

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

　　　　1. 适合多个相同的程序代码的线程去共享同一个资源。

　　　　2. 可以避免java中的单继承的局限性。

　　　　3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

　　　　4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

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

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

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

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

 1 public class RunnableDemo {
 2     public static void main(String[] args) {
 3         Runnable rb = new Runnable() {
 4             @Override
 5             public void run() {
 6                 for (int i = 0 ; i < 30;i++){
 7                     System.out.println(i);
 8                 }
 9             }
10         };
11     new Thread(rb).start();
12     new Thread(rb).start();
13     new Thread(rb).start();
14     }
15 }

2.线程安全

2.1 线程安全

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

我们通过一个案例，演示线程的安全问题： 电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个 (本场电影只能卖100张票)。

我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票) 需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

卖票类

 1 public class Ticket implements Runnable {
 2     private int ticket = 100;
 3     @Override
 4     public void run() {
 5         while(true){
 6             if (ticket > 0){
 7                 try{
 8                     Thread.sleep(100);
 9                 }catch (Exception e){
10                     e.printStackTrace();
11                 }
12                 String name = Thread.currentThread().getName();
13                 System.out.println(name+"正在卖第"+ticket--+"张票.");
14             }
15         }
16     }
17 }

测试类

 1 public class Demo {
 2     public static void main(String[] args) {
 3         Ticket tk = new Ticket();
 4
 5         Thread w1 = new Thread(tk,"1号窗口");
 6         Thread w2 = new Thread(tk,"2号窗口");
 7         Thread w3 = new Thread(tk,"3号窗口");
 8
 9         w1.start();
10         w2.start();
11         w3.start();
12     }
13 }

会出现两种问题：

　　1. 相同的票被卖了两回。

　　2. 不存在的票，比如0票与-1票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

tips：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步， 否则的话就可能影响线程安全。

2.2 线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。 要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制 (synchronized)来解决。

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

　　1. 同步代码块。

　　2. 同步方法。

　　3. 锁机制。

2.3 同步代码块

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

格式:

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

同步锁:

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

　　　　1. 锁对象 可以是任意类型。

　　　　2. 多个线程对象 要使用同一把锁。

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

 1 public class Ticket implements Runnable {
 2     private int ticket = 100;
 3     Object lock = new Object();
 4     @Override
 5     public void run() {
 6         while (true){
 7             synchronized(lock){
 8                 if (ticket > 0){
 9                     try {
10                         Thread.sleep(100);
11                     } catch (InterruptedException e) {
12                         e.printStackTrace();
13                     }
14                     String name = Thread.currentThread().getName();
15                     System.out.println(name+"正在卖第"+ticket--+"张票.");
16                 }
17             }
18         }
19     }
20 }

2.4 同步方法

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

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

同步锁是谁?

　　对于非static方法,同步锁就是this。

　　对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

 1 public class Ticket implements Runnable {
 2     private int ticket = 100;
 3
 4     @Override
 5     public void run() {
 6         while (true) {
 7             sell();
 8         }
 9     }
10
11     private synchronized void sell() {
12         if (ticket > 0) {
13             try {
14                 Thread.sleep(100);
15             } catch (InterruptedException e) {
16                 e.printStackTrace();
17             }
18             String name = Thread.currentThread().getName();
19             System.out.println(name + "正在卖第" + ticket-- + "张票.");
20         }
21     }
22 }

2.5 Lock锁

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

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

　　public void lock() :加同步锁。

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

 1 import java.util.concurrent.locks.Lock;
 2 import java.util.concurrent.locks.ReentrantLock;
 3
 4 public class Ticket implements Runnable {
 5     private int ticket = 100;
 6     Lock lock = new ReentrantLock();
 7
 8     @Override
 9     public void run() {
10         while (true) {
11             lock.lock();
12             if (ticket > 0) {
13                 try {
14                     Thread.sleep(100);
15                 } catch (InterruptedException e) {
16                     e.printStackTrace();
17                 }
18                 String name = Thread.currentThread().getName();
19                 System.out.println(name + "正在卖第" + ticket-- + "张票.");
20             }
21             lock.unlock();
22         }
23     }
24 }

3.线程状态

3.1 线程状态概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中， 有几种状态呢？

在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

线程状态	导致状态发生的条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可 运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器。
Blocked(锁阻 塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时 等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

3.2 Timed Waiting（计时等待）

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。

单独的去理解这句话，真是玄之又玄，其实我们在之前的操作中已经接触过这个状态了，在哪里呢？

在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。 其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)

所以：

　　1. 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。

　　2. 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠

　　3. sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。

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

3.3 BLOCKED（锁阻塞）

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

我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获 取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态

3.4 Waiting（无限等待）

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

 1 public class mbz {
 2     public static void main(String[] args) {
 3         //创建锁对象
 4         Object obj = new Object();
 5
 6         new Thread(){
 7             @Override
 8             public void run(){
 9                 synchronized (obj){
10                     System.out.println("告诉老板要的包子");
11                     try {
12                         obj.wait();
13                     } catch (InterruptedException e) {
14                         e.printStackTrace();
15                     }
16                     System.out.println("包子做好了，开吃");
17                 }
18             }
19         }.start();
20
21         new Thread(){
22             @Override
23             public void run(){
24                 System.out.println("老板开始做包子");
25                 try {
26                     sleep(5000);
27                 } catch (InterruptedException e) {
28                     e.printStackTrace();
29                 }
30
31                 synchronized (obj){
32                     System.out.println("包子做好了，请吃");
33                     obj.notify();
34                 }
35             }
36         }.start();
37     }
38 }