前言

Process与Thread：

• 程序（programm）是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程（process）是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
• 通常在一个进程中可以包含若干个线程（thread），当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

很多多线程是模拟出来的，真正的多线程是指有多个CPU。

核心概念

• 线程就是独立的执行路径
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
• main()称之为主线程，为系统的入口，用于执行整个程序
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
• 线程会带来额外的开销，如cpu调度时间，并发控制开销
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

三种创建线程的方式：

1. 继承Thread类【重点】
2. 实现Runnable接口【重点】
3. 实现Callable接口

继承Thread类

创建线程方式1：继承Thread类，重写run()方法，调用start开启线程。

• public class Thread extends Object implements Runnable

• 构造方法：
  Thread(Runnable target) 分配一个新的 Thread对象。
  Thread(Runnable target, String name) 分配一个新的 Thread对象，具有指定的name作为其名称

• 常用方法：
  void start() 使此线程开始执行; JVM调用此线程的run方法。

简单例子：

//创建线程方式1：继承Thread类，重写run()方法，调用start开启线程
//总结：注意线程开启不一定立即执行，由CPU调度执行
public class ThreadTest1 extends Thread{@Overridepublic void run() {//run方法线程的执行体for (int i = 0; i < 200; i++) {System.out.println("我在学线程---"+i);}}public static void main(String[] args) {//main线程，主线程//创建一个线程对象ThreadTest1 tt = new ThreadTest1();//调用start()tt.start();for (int i = 0; i < 1000; i++) {System.out.println("（主）我在看代码---"+i);}}
}

网图下载例子：

//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread{private String url;//网络图片地址private String name;//保存的文件名public TestThread2(String url,String name){this.url = url;this.name = name;}//  下载图片线程的执行体@Overridepublic void run() {WebDownloader webDownloader = new WebDownloader();webDownloader.downloader(url,name);System.out.println("下载了文件名为"+name+"的文件");}public static void main(String[] args) {TestThread2 t1 = new TestThread2("https://www.kuangstudy.com/assert/course/c1/01.jpg","图片1.jpg");TestThread2 t2 = new TestThread2("https://www.kuangstudy.com/assert/course/c1/02.jpg","图片2.jpg");TestThread2 t3 = new TestThread2("https://www.kuangstudy.com/assert/course/c1/03.jpg","图片3.jpg");t1.start();t2.start();t3.start();}
}
//下载器
class WebDownloader{//下载方法public void downloader(String url,String name){try {FileUtils.copyURLToFile(new URL(url),new File(name));} catch (IOException e) {e.printStackTrace();System.out.println("IO异常，Downloader出现问题");}}
}

实现Runnable接口

创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法。

• public interface Runnable：
  Runnable接口应由任何类实现，其实例将由线程执行。 该类必须定义一个无参数的方法，称为run 。

简单例子：

//创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class ThreadTest3 implements Runnable{@Overridepublic void run() {//run方法线程体for (int i = 0; i < 200; i++) {System.out.println("我在学线程---"+i);}}public static void main(String[] args) {//创建Runnable接口的实现类对象ThreadTest3 tt = new ThreadTest3();//创建线程对象，通过线程对象来开启我们的线程，代理new Thread(tt).start();for (int i = 0; i < 1000; i++) {System.out.println("（主）我在看代码---"+i);}}
}

上述两个方法小结

继承Thread类：

• 子类继承Thread类具备多线程能力
• 启动线程：子类对象.start()
• 不建议使用。为了避免面向对象单继承局限性

实现Runnable接口：

• 实现接口Runnable具有多线程能力
• 启动线程：传入目标对象+Thread对象.start()
• 推荐使用。能避免单继承局限性，灵活方便，方便同一对象被多个线程使用。 例如：

//一份资源
ThreadTest tt = new ThreadTest();//多个代理
new Thread(tt,"张三").start();
new Thread(tt,"李四").start();
new Thread(tt,"你好").start();

代码例子（龟兔赛跑）作为总结：

//模拟龟兔赛跑
public class Race implements Runnable{//胜利者private static String  winner;@Overridepublic void run() {for (int i = 0; i <= 100; i++) {//模拟兔子睡觉if (Thread.currentThread().getName().equals("兔子") && i%10==0){try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}//判断比赛是否结束boolean flag = gameOver(i);if (flag){break;}System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");}}//判断是否完成比赛private boolean gameOver(int steps){//判断是否有胜利者if (winner!=null){//已经存在胜利者return true;}{if (steps>=100){winner=Thread.currentThread().getName();System.out.println("winner is"+winner);return true;}}return false;}public static void main(String[] args) {Race race = new Race();new Thread(race,"乌龟").start();new Thread(race,"兔子").start();}
}

实现Callable接口

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5. 提交执行：Future\<Boolean\> result1 = ser.submit(t1);
6. 获取结果：boolean r1 = result1.get();
7. 关闭服务：ser.shutdownNow();

网图下载例子：

//线程创建方式3：实现Callable接口
//Callable的好处：1.可以定义返回值；2.可以抛出异常public class CallableTest implements Callable<Boolean> {private String url;//网络图片地址private String name;//保存的文件名public CallableTest(String url,String name){this.url = url;this.name = name;}//  下载图片线程的执行体@Overridepublic Boolean call() {WebDownloader1 webDownloader = new WebDownloader1();webDownloader.downloader(url,name);System.out.println("下载了文件名为"+name+"的文件");return true;}public static void main(String[] args) throws ExecutionException, InterruptedException {CallableTest ct1 = new CallableTest("https://www.kuangstudy.com/assert/course/c1/01.jpg","c图片1.jpg");CallableTest ct2 = new CallableTest("https://www.kuangstudy.com/assert/course/c1/02.jpg","c图片2.jpg");CallableTest ct3 = new CallableTest("https://www.kuangstudy.com/assert/course/c1/03.jpg","c图片3.jpg");// 创建执行对象ExecutorService ser = Executors.newFixedThreadPool(3);// 提交执行：Future<Boolean> r1 = ser.submit(ct1);Future<Boolean> r2 = ser.submit(ct2);Future<Boolean> r3 = ser.submit(ct3);// 获取结果：boolean rs1 = r1.get();boolean rs2 = r2.get();boolean rs3 = r3.get();System.out.println(rs1);System.out.println(rs2);System.out.println(rs3);// 关闭服务ser.shutdownNow();}
}
// 下载器
class WebDownloader1{// 下载方法public void downloader(String url,String name){try {FileUtils.copyURLToFile(new URL(url),new File(name));} catch (IOException e) {e.printStackTrace();System.out.println("IO异常，Downloader出现问题");}}
}

并发问题简介

// 多个线程同时操作同一个对象
// 买火车票的例子
public class ThreadTest4 implements Runnable{// 票数private int ticketNums = 10;@Overridepublic void run() {while (true){if (ticketNums<=0){break;}//模拟延时try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票");}}public static void main(String[] args) {ThreadTest4 ticket = new ThreadTest4();new Thread(ticket,"小明").start();new Thread(ticket,"老师").start();new Thread(ticket,"黄牛党").start();}
}

结果：

小明拿到了第10张票
老师拿到了第8张票
黄牛党拿到了第9张票
黄牛党拿到了第7张票
小明拿到了第7张票
老师拿到了第7张票
黄牛党拿到了第6张票
…

可见发生了多个人取到同一张票

静态代理模式

静态代理模式总结：

• 真实对象和代理对象都要实现同一个接口
• 代理对象要代理真实角色

好处：
1.代理对象可以做很多真实对象做不了的事情
2.真实对象专注做自己的事情

public class StaticProxy {public static void main(String[] args) {new Thread( ()-> System.out.println("我爱你") ).start();// Thread也实现了Runnable接口，所以代理了Runnable接口，Thread调用了start方法（Runnable接口只有run方法，Thread调用了start方法时虚拟机调用了run方法），// 相当于WeddingCompany代理了Marry，调用了HappyMarry方法new WeddingCompany(new You()).HappyMarry();;}
}interface Marry{void HappyMarry();
}// 真实角色，你。 你去结婚
class You implements Marry{@Overridepublic void HappyMarry() {System.out.println("结婚了，好开心");}
}// 代理角色，婚庆公司。 帮助你办婚礼
class WeddingCompany implements Marry{// 代理谁-->真实目标角色private Marry target;public WeddingCompany(Marry target) {this.target = target;}@Overridepublic void HappyMarry() {before();this.target.HappyMarry();//这是真实对象after();}private void before() {System.out.println("结婚之前，布置现场");}private void after() {System.out.println("办完婚礼后，付尾款");}
}

线程状态

线程停止（stop）

• 建议线程正常停止（自己停下来）。即利用次数，不建议死循环
• 建议使用标志位作为终止，当flag=false，则线程终止运行
• 不要使用stop或者destroy等过时或不建议使用的方法

基本步骤：

1. 线程中定义线程体使用的标识
2. 线程体使用该标识
3. 对外提供方法改变标识

例子：

public class TestStop implements Runnable{// 1.设置一个标志位private  boolean flag = true;@Overridepublic void run() {int i = 0;while (flag){System.out.println("run...Thread"+i++);}}// 2.设置一个公开的方法停止线程，转换标志位public void stop(){this.flag = false;}public static void main(String[] args) {TestStop testStop = new TestStop();new Thread(testStop).start();for (int i = 0; i < 1000; i++) {System.out.println("main"+i);if (i==900) { // 主线程到i=900的时候才停止线程testStop.stop();System.out.println("线程停止了");}}}
}

输出：

…
main900
run…Thread662
线程停止了
main901
…

线程休眠（sleep）

• sleep(毫秒) 指定当前线程阻塞的毫秒数
• sleep存在异常InterruptedException
• sleep时间达到后，线程进入就绪状态
• sleep可以模拟网络延时，倒计时等
• 每一个对象都有一个锁，sleep不会释放锁

例子1：在前面的了解并发问题的买票例子中可以加入延时Thread.sleep(100);,从而模拟网络延迟，这样可以放大问题的发生性。

例子2：模拟倒计时。

public class Countdown {public static void main(String[] args) {try {countdown();} catch (InterruptedException e) {e.printStackTrace();}}//模拟倒计时public static void countdown() throws InterruptedException {int num = 10;while (true){Thread.sleep(1000);System.out.println(num--);if (num<=0){break;}}}
}

例子3：打印当前系统时间

public class SystemTime {public static void main(String[] args) throws InterruptedException {//打印当前系统时间Date time = new Date(System.currentTimeMillis());//获取当前系统时间while(true){try {Thread.sleep(1000);System.out.println(new SimpleDateFormat("HH:mm:ss").format(time));time = new Date(System.currentTimeMillis());//更新当前时间} catch (InterruptedException e) {e.printStackTrace();}}}}

线程礼让（yield）

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 注意：让CPU重新调度，礼让不一定成功！看CPU心情

public class YieldTest {public static void main(String[] args) {MyYield myYield = new MyYield();new Thread(myYield,"A").start();new Thread(myYield,"B").start();}
}class MyYield implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"线程开始执行");Thread.yield();//礼让System.out.println(Thread.currentThread().getName()+"线程停止执行");}
}

输出：（礼让不成功）

A线程开始执行
A线程停止执行
B线程开始执行
B线程停止执行

输出：（礼让成功）

A线程开始执行
B线程开始执行
A线程停止执行
B线程停止执行

线程强制执行（join）

• join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞（可以想象成插队）

public class JoinTest implements Runnable{@Overridepublic void run() {for (int i = 1; i <= 1000; i++) {System.out.println("线程vip来了"+i);}}public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new JoinTest());thread.start();for (int i = 0; i < 500; i++) {if(i==200){thread.join();//主线程跑到200的时候插队,插队者跑完1000才继续其他的线程，包括主线程}System.out.println("main"+i);}}
}

线程状态观测

线程状态。 线程可以处于以下状态之一：

• NEW 尚未启动的线程处于此状态。
• RUNNABLE 在Java虚拟机中执行的线程处于此状态。
• BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
• WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
• TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
• TERMINATED 已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

// 观察线程的状态
public class StateTest {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(()->{for (int i = 0; i < 5; i++) {// 线程启动后睡五秒钟try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("干活！");});// 观察状态Thread.State state = thread.getState();System.out.println(state);// 观察new了一个线程后的状态// 观察启动后thread.start();// 启动线程state = thread.getState();System.out.println(state);// 观察线程run后的状态while(state!=Thread.State.TERMINATED){ // 只要线程不终止，就一直输出状态Thread.sleep(100);state = thread.getState();// 更新线程状态System.out.println(state);// 输出状态}}
}

输出：

NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
…
TIMED_WAITING
干活！
TERMINATED

【注意】线程start后不一定立即执行，而是处于RUNNABLE状态，即就绪状态。线程休眠的5秒钟内一直是TIMED_WAITING状态，睡醒之后就干活，干完活就线程终止

线程优先级

• Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

• 线程的优先级用数字表示，范围从1~10：（数字越大优先级越高）
  Thread.MIN_PRIORITY = 1;
  Thread.MAX_PRIORITY = 10;
  Thread.NORM_PRIORITY = 5;
  【注意】优先级低只是意味着获得调度的概率低。并不是优先级低就不会被先调用，这都是取决于CPU。

• 使用以下方式改变或者获取优先级：
  getPriority()
  setPriority(int x)

• 如果需要设置优先级，先设定好优先级再start()

// 测试线程的优先级
public class PriorityTest {public static void main(String[] args) {System.out.println(Thread.currentThread().getName()+"主线程优先级:"+Thread.currentThread().getPriority());MyPriority myPriority = new MyPriority();Thread t1 = new Thread(myPriority);Thread t2 = new Thread(myPriority);Thread t3 = new Thread(myPriority);Thread t4 = new Thread(myPriority);// 先设置优先级 再启动t1.start();t2.setPriority(1);t2.start();t3.setPriority(4);t3.start();t4.setPriority(Thread.MAX_PRIORITY);// MAX_PRIORITY=10t4.start();}
}class MyPriority implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"优先级:"+Thread.currentThread().getPriority());}
}

守护线程

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 守护线程如：后台记录操作日志，监控内存，垃圾回收等

public class DaemonTest {public static void main(String[] args) {God god = new God();You1 you = new You1();Thread thread = new Thread(god);thread.setDaemon(true); // 默认是false，表示用户线程，一般都是用户线程thread.start();// 上帝守护线程启动new Thread(you).start();// 你 用户线程启动}
}// 上帝
class God implements Runnable{@Overridepublic void run() {while (true){System.out.println("上帝保佑你");}}
}// 你
class You1 implements Runnable{@Overridepublic void run() {for (int i = 0; i <= 36500; i++) {System.out.println("你一生幸福快乐地活着");}System.out.println("goodbye world");}
}

用户线程停止之后，守护线程还在运行，因为虚拟机停止需要一段时间。

后续内容见《Java学习笔记5-2》