课程地址：深入浅出Java多线程
课程讲师：Arthur
进程
程序（任务）的执行过程 （动态性-当双击运行）
持有资源（共享内存，共享文件）和线程（进程是资源的载体，也是线程的载体，脱离进程去谈论线程没有意义；）
线程是系统最小的执行单元
同一进程中有多个线程
线程共享进程的资源
线程交互方式：互斥，同步。
011.png
/**
* 军队线程
* 模拟作战双方的行为
*/
public class ArmyRunnable implements Runnable {
//volatile保证了线程可以正确的读取其他线程写入的值
//可见性 ref JMM， happens-before原则
volatile boolean keepRunning = true;
@Override
public void run() {
while(keepRunning){
//发动5连击
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"进攻对方["+i+"]");
//让出了处理器时间，下次该谁进攻还不一定呢！
Thread.yield();
}
}
System.out.println(Thread.currentThread().getName()+"结束了战斗！");
}
}
/**
* 英雄任务
*/
public class KeyPersonThread extends Thread {
public void run(){
System.out.println(Thread.currentThread().getName()+"开始了战斗！");
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"左突右杀,攻击隋军...");
}
System.out.println(Thread.currentThread().getName()+"结束了战斗！");
}
}
/**
* 隋唐演义大戏舞台
*/
public class Stage extends Thread {
public void run(){
System.out.println("欢迎观看隋唐演义");
//让观众们安静片刻，等待大戏上演
try {
Thread.sleep(5000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System.out.println("大幕徐徐拉开");
try {
Thread.sleep(5000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System.out.println("话说隋朝末年，隋军与农民起义军杀得昏天黑地...");
ArmyRunnable armyTaskOfSuiDynasty = new ArmyRunnable();
ArmyRunnable armyTaskOfRevolt = new ArmyRunnable();
//使用Runnable接口创建线程
Thread armyOfSuiDynasty = new Thread(armyTaskOfSuiDynasty,"隋军");
Thread armyOfRevolt = new Thread(armyTaskOfRevolt,"农民起义军");
//启动线程，让军队开始作战
armyOfSuiDynasty.start();
armyOfRevolt.start();
//舞台线程休眠，大家专心观看军队厮杀
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("正当双方激战正酣，半路杀出了个程咬金");
Thread mrCheng = new KeyPersonThread();
mrCheng.setName("程咬金");
System.out.println("程咬金的理想就是结束战争，使百姓安居乐业！");
//停止军队作战
//停止线程的方法
armyTaskOfSuiDynasty.keepRunning = false;
armyTaskOfRevolt.keepRunning = false;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
/*
* 历史大戏留给关键人物
*/
mrCheng.start();
//万众瞩目，所有线程等待程先生完成历史使命
try {
mrCheng.join(); // 所有线程会等待调用join()方法的这个线程执行完成后，再执行后续内容
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("战争结束，人民安居乐业，程先生实现了积极的人生梦想，为人民作出了贡献！");
System.out.println("谢谢观看隋唐演义，再见！");
}
public static void main(String[] args) {
new Stage().start();
}
}
如何正确的停止Java中的线程
废弃stop()方法
使用退出标志
interrupt()方法初衷并不是用于停止线程，isInterrupted() 和 interrupted()测试当前线程是否被中断
public class WrongWayStopThread extends Thread{
public static void main(String[] args){
WrongWayStopThread thread = new WrongWayStopThread();
System.out.println("Starting thread ...");
thread.start() ;
try{
Threaf.sleep(3000) ;
}catch(InterruptedException e){
e.printStackTrace() ;
}
System.out.println("Interrupting thread ...");
thread.interrupt() ; // 并不能使程序停下来
try{
Threaf.sleep(3000) ;
}catch(InterruptedException e){
e.printStackTrace() ;
}
System.out.println("Stopping thread ...");
}
public void run(){
// while(true){
while(!this.isInterrupted()){ // 线程停下，其实相当于退出旗标的方法
System.out.println("Thread is running ...");
/* long time = System.currentTimeMillis() ;
while((System.currentTimeMillis() - time) < 1000){
// 减少屏幕输入的空循环
}
*/
// 换成等效代码，线程不能正常结束，且抛出异常。原因是：当现场调用某些方法进入阻塞状态，此时该线程再被调用interrupt()方法，会产生两个结果，第一是中断状态被清除(this.isInterrupted())，线程的isInterrupted()方法不能返回表示是否被中断的正确状态；第二是sleep()方法会收到一个InterruptedException异常
Threaf.sleep(3000) ;
}
}
}
推荐使用退出旗标的方式退出线程
线程的交互
/**
* 宇宙的能量系统
* 遵循能量守恒定律：
* 能量不会凭空创生或消失，只会从一处转移到另一处
*/
public class EnergySystem {
//能量盒子，能量存贮的地方
private final double[] energyBoxes;
private final Object lockObj = new Object(); // 锁对象
/**
*
* @param n 能量盒子的数量
* @param initialEnergy 每个能量盒子初始含有的能量值
*/
public EnergySystem(int n, double initialEnergy){
energyBoxes = new double[n];
for (int i = 0; i < energyBoxes.length; i++)
energyBoxes[i] = initialEnergy;
}
/**
* 能量的转移，从一个盒子到另一个盒子
* @param from 能量源
* @param to 能量终点
* @param amount 能量值
*/
public void transfer(int from, int to, double amount){
synchronized(lockObj){
// if (energyBoxes[from] < amount)
// return;
//while循环，保证条件不满足时任务都会被条件阻挡
//而不是继续竞争CPU资源
// Wait set
while (energyBoxes[from] < amount){
try {
//条件不满足, 将当前线程放入Wait Set
lockObj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(Thread.currentThread().getName());
energyBoxes[from] -= amount;
System.out.printf("从%d转移%10.2f单位能量到%d", from, amount, to);
energyBoxes[to] += amount;
System.out.printf(" 能量总和：%10.2f%n", getTotalEnergies());
//唤醒所有在lockObj对象上等待的线程
lockObj.notifyAll();
}
}
/**
* 获取能量世界的能量总和
*/
public double getTotalEnergies(){
double sum = 0;
for (double amount : energyBoxes)
sum += amount;
return sum;
}
/**
* 返回能量盒子的长度
*/
public int getBoxAmount(){
return energyBoxes.length;
}
}
public class EnergyTransferTask implements Runnable{
//共享的能量世界
private EnergySystem energySystem;
//能量转移的源能量盒子下标
private int fromBox;
//单次能量转移最大单元
private double maxAmount;
//最大休眠时间（毫秒）
private int DELAY = 10;
public EnergyTransferTask(EnergySystem energySystem, int from, double max){
this.energySystem = energySystem;
this.fromBox = from;
this.maxAmount = max;
}
public void run() {
try{
while (true){
int toBox = (int) (energySystem.getBoxAmount()* Math.random());
double amount = maxAmount * Math.random();
energySystem.transfer(fromBox, toBox, amount);
Thread.sleep((int) (DELAY * Math.random()));
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
public class EnergySystemTest {
//将要构建的能量世界中能量盒子数量
public static final int BOX_AMOUNT = 100;
//每个盒子初始能量
public static final double INITIAL_ENERGY = 1000;
public static void main(String[] args){
EnergySystem eng = new EnergySystem(BOX_AMOUNT, INITIAL_ENERGY);
for (int i = 0; i < BOX_AMOUNT; i++){
EnergyTransferTask task = new EnergyTransferTask(eng, i, INITIAL_ENERGY);
Thread t = new Thread(task,"TransferThread_"+i);
t.start();
}
}
}
争用条件：当多个线程同时共享同一数据（内存区域）时，每个线程都尝试操作该数据，从而导致数据被破坏（corrupted），这种现象称为争用条件。
012.png
线程交互：互斥与同步
互斥：同一时间只能有一条线程对我们的关键数据或临界区进行操作。
同步：线程之间的通信机制，如某一线程做了一件事，用某种方式告诉其他的线程做完了。
同步实现：wait() / notify() / notifyAll()
如何扩展Java并发的知识
-
Java Memory Mode
- JMM描述了Java线程如何通过内存进行交互
- happens-before原则
- synchronized、volatile & final怎么实现这一原则
-
Lock & Condition
- Java锁机制和等待条件的高层实现
- java.util.concurrent.locks
-
线程安全性
- 原子性与可见性
- java.util.concurrent.atomic
- synchronized & volatile
- DeadLocks
-
多线程编程常用的交互模型
- Producer-Consumer模型
- Read-Write Lock模型
- Future模型
- Worker Thread模型
-
Java5中并发编程工具
- java.util.concurrent
- 线程池ExecutorService
- Callable & Future
- BlockingQueue
