“核心技术：并发”的版本间差异

2020年10月20日 (二) 16:58的版本

什么是线程

一个程序同时执行多个任务，每一个任务称为一个线程（thread), 它是线程控制的简称。

进程与线程有的区别，在于每个进程拥有自己的一整套变量，而线程则共享数据。
共享变量使线程之间的通信比进程之间的通信更有效、更容易。

使用线程

实现线程的两种方式：

实现Runnable接口，利用接口构造Thread对象；（Runnable 是一个函数式接口，可以用lambda 表达式）
```
Runnable r = () -> { /*task code*/ };
Thread t = new Thread(r);
```

继承Thread类，构造一个子类的对象；

class MyThread extends Thread
{
   public void run()
   {
      //task code
   }
}

不要调用Thread类或Runnable对象的run方法，而应该调用Thread.start方法。
直接调用run 方法，只会执行同一个线程中的任务，而不会启动新线程。
如果有很多任务，要为每个任务创建一个独立的线程所付出的代价太大了。可以使用线程池来解决这个问题

中断线程

当线程的run 方法执行方法体中最后一条语句后，并经由执行return 语句返冋时，或者出现了在方法中没有捕获的异常时，线程将终止。

在Java 的早期版本中，还有一个stop方法，其他线程可以调用它终止线程。
因为，stop会瞬间强行停止一个线程，且该线程持有的锁并不能释放；所以，这个方法现在已经被弃用了。

Java中断及中断响应

线程状态

线程可以有如下6 种状态：

New ( 新创建）
Runnable (可运行）
Blocked ( 被阻塞）
Waiting ( 等待）
Timed waiting (计时等待）
Terminated ( 被终止）

可调用“getState”方法获取一个线程的当前状态；

新创建线程

用 new 操作符创建一个新线程，未调用 start 方法，该线程还没有开始运行，即 New 状态

可运行线程

一旦调用 start 方法，则线程处于 runnable 状态。

（Java 的规范说明没有将它作为一个单独状态：正在运行中的线程仍然处于可运行状态。）

结合线程状态图，理解为：“可运行” = “运行” + “就绪”；

被阻塞线程和等待线程

当线程处于被阻塞或等待状态时，它暂时不活动。它不运行任何代码且消耗最少的资源。直到线程调度器重新激活它。

（看到里有点混，于是Java的阻塞、等待及相关方法）

阻塞（blocked）

阻塞：当一个线程请求锁，而该资源被其他线程持有时，该线程被置为阻塞状态。

请求内部的对象锁（非java.util.concurrent库中的锁）。

等待（waiting）

等待：当线程等待另一个线程通知调度器一个条件时，该线程主动进入等待状态。
如：

Object.wait
Thread.join
java.util.concurrent 库中的Lock 或Condition

计时等待（timed waiting）

计时等待状态将一直保持到超时期满或者接收到适当的通知。
如：

Object.wait(long millis)
Thread.join(long millis)
java.util.concurrent 库中的Lock(long millis) 或Condition(long millis)

被终止的线程（Terminated）

线程因如下两个原因之一而被终止：

因为run 方法正常退出而自然死亡。
因为一个没有捕获的异常终止了nm 方法而意外死亡。

不应该使用“stop”方法来终止线程！（虽然能做到）

线程属性

线程的各种属性，如：线程优先级、守护线程、线程组以及处理未捕获异常的处理器。

	private int priority;
	...
	private boolean daemon = false;
	...
	private ThreadGroup group;
	

    public final static int MIN_PRIORITY = 1;

    public final static int NORM_PRIORITY = 5;

    public final static int MAX_PRIORITY = 10;
	
	...
	// null unless explicitly set
    private volatile UncaughtExceptionHandler uncaughtExceptionHandler;

    // null unless explicitly set
    private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;

线程优先级（Priority）

默认情况下，线程会继承它的父线程的优先级；（可以在 init 方法中发现，同时还会继承 “group”、“daemon”）
可以用setPriority 方法提高或降低任何一个线程的优先级。

不要将程序构建为功能的正确性依赖于优先级。

如果确实要使用优先级， 应该避免初学者常犯的一个错误。如果有几个高优先级的线程没有进入非活动状态， 低优先级的线程可能永远也不能执行。每当调度器决定运行一个新线程时， 首先会在具有高优先级的线程中进行选择， 尽管这样会使低优先级的线程完全饿死。

【？？？不用动态优先级吗，还是和底层实现有关？】

守护线程（Daemon）

守护线程的唯一用途是为其他线程提供服务，当只剩下守护线程时，虚拟机就退出了。
可以通过调用“t .setDaemon(true);”将线程转换为守护线程（daemon thread)。
守护线程应该永远不去访问固有资源，如文件、数据库，因为它会在任何时候甚至在一个操作的中间发生中断。

线程组（ThreadGroup）

线程组是一个可以统一管理的线程集合。默认情况下，创建的所有线程属于相同的线程组，但是，也可能会建立其他的组。现在引入了更好的特性用于线程集合的操作，所以建议不要在自己的程序中使用线程组。

未捕获异常处理器（uncaughtExceptionHandler）

线程的run 方法不能抛出任何受查异常。非受査异常会导致线程终止，在线程死亡之前，异常被传递到一个用于未捕获异常的处理器。
该处理器必须属于一个实现Thread.UncaughtExceptionHandler接口的类，这个接口只有—个方法“void uncaughtException(Thread t, Throwable e);”

同步

多个线程共享同一数据时，线程发出一个方法调用，在没有得到结果之前，这个调用就不返回，同时其它的线程也不能调用这个方法。

锁对象

有两种机制防止代码块受并发访问的干扰：

Java 语言提供一个synchronized 关键字
并且Java SE 5.0 引入了ReentrantLock 类。

把解锁操作括在finally 子句之内是至关重要的。如果在临界区的代码抛出异常，锁必须被释放。否则，其他线程将永远阻塞。
如果使用锁，就不能使用带资源的try 语句。

锁是可重入的，因为线程可以重复地获得已经持有的锁。锁保持一个持有计数（ holdcount ) 来跟踪对lock 方法的嵌套调用。线程在每一次调用lock 都要调用unlock 来释放锁。由于这一特性，被一个锁保护的代码可以调用另一个使用相同的锁的方法。

示例：

public class Bank {
	private Lock bankLock = new ReentrantLock0；// ReentrantLock implements the Lock interface
	...
	public void transfer(int from, int to, int amount) {
		bankLock.lock();
		try {
			System.out.print(Thread.currentThread0);
			accounts[from] -= amount;
			System.out.printf(" X10.2f from %A to Xd", amount, from, to);
			accounts[to] += amount;
			System.out.printf(" Total Balance: X10.2fXn", getTotalBalanceO)；
		}
		finally {
			banklock.unlockO;
		}
	}
}

如上：

transfer 方法调用getTotalBalance 方法，这也会封锁bankLock 对象，此时bankLock对象的持有计数为2。
当getTotalBalance 方法退出的时候，持有计数变回1。
当transfer 方法退出的时候，持有计数变为0。线程释放锁。

条件对象（Condition）

条件对象用于管理那些已经获得了一个锁但是却不能做有用工作的线程。

使用

一个锁对象可以有一个或多个相关的条件对象，用 newCondition 方法获得一个条件对象。

class Bank
{
   private Condition sufficientFunds;
   public BankO
   { 
      sufficientFunds = bankLock.newConditionO;
   }
}

当条件不满足时，调用await：
```
sufficientFunds.await();
```
当前线程现在被阻塞了，并放弃了锁。

一旦一个线程调用await方法，它进人该条件的等待集。当锁可用时，该线程不能马上解除阻塞。相反，它处于阻塞状态，直到另一个线程调用同一条件上的signalAll 方法时为止。
重新激活因为这一条件而等待的所有线程signalAll：
```
sufficientFunds,signalAll();
```

至关重要的是最终需要某个其他线程调用signalAll 方法
调用signalAll 不会立即激活一个等待线程。它仅仅解除等待线程的阻塞，以便这些线程可以在当前线程退出同步方法之后，通过竞争实现对对象的访问。

示例：

public void transfer(int from, int to, int amount)
{
   bankLock.lockO；
   try
   {
      while (accounts[from] < amount)
         sufficientFunds.awaitO；
      
      // transfer funds
      ...
      
      
      sufficientFunds.signalAll()；
   }
   finally
   {
      bankLock.unlock0;
   }
}

synchronized 关键字

有关锁和条件的关键之处：

锁用来保护代码片段，任何时刻只能有一个线程执行被保护的代码。
锁可以管理试图进入被保护代码段的线程。
锁可以拥有一个或多个相关的条件对象。
每个条件对象管理那些已经进入被保护的代码段但还不能运行的线程。

synchronized 与 wait、notifyAll

从1.0 版开始，Java中的每一个对象都有一个内部锁。如果一个方法用 synchronized 关键字声明，那么对象的锁将保护整个方法。也就是说，要调用该方法， 线程必须获得内部的对象锁。

内部对象锁只有一个相关条件。wait 方法添加一个线程到等待集中，notifyAll /notify 方法解除等待线程的阻塞状态。

每一个对象有一个内部锁，并且该锁有一个内部条件。

即：

public synchronized void methodO
{
   method body
}

等价于

public void methodQ
{
   this.intrinsidock.1ock();
   try
   {
      method body
   }
   finally { this.intrinsicLock.unlockO; }
}

wait 、notityAll等价于

intrinsicCondition.await();
intrinsicCondition.signalAll();

示例

class Bank
{
   private double[] accounts;
   public synchronized void transfer(int from，int to, int amount) throws InterruptedException
   {
      while (accounts[from] < amount)
         wait();      // wait on intrinsic object lock's single condition
      accounts[from] -= amount ;
      accounts[to] += amount ;
      notifyAll();      // notify all threads waiting on the condition
   }
   public synchronized double getTotalBalanceO { . . . }
}

Synchronized 使用

将静态方法声明为 synchronized 时，该方法获得相关的类对象的内部锁，没有其他线程可以调用同一个类的这个或任何其他的同步静态方法。
例如，如果Bank 类有一个静态同步的方法，那么当该方法被调用时，Bank.class对象的锁被锁住。

内部锁和条件存在一些局限。包括：

不能中断一个正在试图获得锁的线程。
试图获得锁时不能设定超时。
每个锁仅有单一的条件，可能是不够的。

最好使用JUC框架（java.util.concurrent）提供的锁，而不是“Lock/Condition”和“synchronized”。

同步阻塞

除了调用同步方法，还有另一种机制可以获得锁：通过进入一个同步阻塞。

如：

public class Bank
{
   private doublet[] accounts;
   private Object lock = new Object();
   ...
   public void transfer(int from, int to, int amount)
   {
      synchronized (lock) // an ad-hoc lock
      {
         accounts[from] -= amount;
         accounts[to] += amount;
      }
      System.out.print1n( ... );
   }
}

lock 对象被创建仅仅是用来使用每个Java 对象持有的锁。

监视器概念（monitor）

监视器可以在不需要程序员考虑如何加锁的情况下，就可以保证多线程的安全性。
监视器具有如下特性：

监视器是只包含私有域的类。
每个监视器类的对象有一个相关的锁。
使用该锁对所有的方法进行加锁。换句话说，如果客户端调用obj.methood() , 那么obj对象的锁是在方法调用开始时自动获得，并且当方法返回时自动释放该锁。因为所有的域是私有的，这样的安排可以确保一个线程在对对象操作时，没有其他线程能访问该域。
该锁可以有任意多个相关条件。

Java中以不是很精确的方式采用了监视器概念：

用synchronized 关键字声明方法
通过调用wait/notifyAU/notify 来访问条件变量

Java 对象不同于监视器，从而使得线程的安全性下降：

域不要求必须是private。
方法不要求必须是synchronized。
内部锁对客户是可用的。【？】

Volatile 域

volatile 关键字为实例域的同步访问提供了一种免锁机制：

如果声明一个域为volatile，那么编译器和虚拟机就知道该域是可能被另一个线程并发更新的。

volatile 不保证原子性

原子性

java.util.concurrent.atomic 包中有很多类使用了很高效的机器级指令（而不是使用锁）来保证其他操作的原子性（操作不会中断）。

死锁（deadlock）

互斥访问：一个资源每次只能被一个线程使用。
请求与保持：一个线程因请求资源而阻塞时，对已获得的资源保持不放。
不可抢占：线程已获得的资源，在未使用完之前，不能强行剥夺。
循环等待：若干线程之间形成一种头尾相接的循环等待资源关系。

线程局部变量

锁测试域超时

读/写锁（ReenterantReadWriteLock）

为什么弃用 stop 和 suspend 方法

阻塞队列

线程安全的集合

Callable 与 Future

执行器

同步器

线程与Swing

@@ 第477行： / 第477行： @@
 === 死锁（deadlock） ===
+# 互斥访问：一个资源每次只能被一个线程使用。
+# 请求与保持：一个线程因请求资源而阻塞时，对已获得的资源保持不放。
+# 不可抢占：线程已获得的资源，在未使用完之前，不能强行剥夺。
+# 循环等待：若干线程之间形成一种头尾相接的循环等待资源关系。
+相关：
+* 银行家算法
 === 线程局部变量 ===

“核心技术：并发”的版本间差异

2020年10月20日 (二) 16:58的版本

什么是线程

使用线程

相关方法

java.Iang.Thread

java.lang.Runnable

中断线程

相关方法

java.Iang.Thread

线程状态

新创建线程

可运行线程

被阻塞线程和等待线程

阻塞（blocked）

等待（waiting）

计时等待（timed waiting）

被终止的线程（Terminated）

相关方法

java.iang.Thread

线程属性

线程优先级（Priority）

相关方法

java.lang.Thread

守护线程（Daemon）

相关方法

java.lang.Thread

线程组（ThreadGroup）

相关方法

java.lang.ThreadGroup

未捕获异常处理器（uncaughtExceptionHandler）

相关方法

java.lang.Thread

java.Iang.Thread.UncaughtExceptionHandler

同步

锁对象

示例：

相关方法

java.util.concurrent.locks.Lock

java,util.concurrent.locks.ReentrantLock

条件对象（Condition）

使用

示例：

synchronized 关键字

synchronized 与 wait、notifyAll

示例

Synchronized 使用

相关方法

java.lang.Object

同步阻塞

监视器概念（monitor）

Volatile 域

原子性

死锁（deadlock）

线程局部变量

锁测试域超时

读/写锁（ReenterantReadWriteLock）

为什么弃用 stop 和 suspend 方法

阻塞队列

线程安全的集合

Callable 与 Future

执行器

同步器

线程与Swing

导航菜单

搜索