学习目标：

1.线程简介

普通方法调用和多线程的区别编辑

Process（进程）与Thread（线程）

本章核心概念

2.线程创建

2.1 三种创建方式

2.2Thread（重点）

2.3Runnable接口（重点）

例子1：抢火车票

例子2：龟兔赛跑

2.4实现Callable接口（了解）

2.5静态代理模式

2.6Lambda表达式

3线程5种状态

3.1线程停止——stop()

3.2线程休眠——sleep()

3.3线程礼让——Yield()

3.4线程强制执行——Join()

3.5观测线程状态

3.6.线程的优先级

3.7守护线程——daemon

4.线程的同步

4.1案例：不安全购票

4.4同步方法及同步块

补充：CopyOnWriteArrayList

4.5死锁

4.6lock锁

synchronized 与Lock的对比

5.线程通信

解决方法一：并发协作模型“生产者/消费者模式”--->管程法

解决方法二：并发协作模型“生产者/消费者模式”--->信号灯法

5.1线程池

6总结

学习目标：

1.线程简介	4.线程同步（重点）
2.线程实现（重点）	5.线程通信问题
3.线程状态	6.高级主题

1.线程简介

普通方法调用和多线程的区别

Process（进程）与Thread（线程）

说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。
注意:很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

本章核心概念

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

2.线程创建

2.1 三种创建方式

2.2Thread（重点）

自定义线程类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

package com.study.Thread;
//创建进程方式一：继承Thread类，重写run（）方法
//调用start开启线程
//总结：线程不一定立即执行，有CPU调度安排
public class ThreadDemo extends Thread {//run方法线程体@Overridepublic void run() {for(int i=0; i<20; i++) {System.out.println("我在看代码---"+i);}}//main线程，主线程public static void main(String[] args) {//创建一个线程对象ThreadDemo threadDemo=new ThreadDemo(); //调用start()方法threadDemo.start();//两条线程交替执行//只是运行速度快，我们感觉是同时执行for (int i = 0; i < 20; i++) {System.out.println("我在学习多线程---"+i);}}
}

练习：

package com.study.Thread;import java.io.File;
import java.io.IOException;
import java.net.URL;import org.apache.commons.io.FileUtils;//练习Thread，实现多线程下载图片
public class ThreadDemo2 extends Thread{private String url;//保存图片urlprivate String name;//保存图片名称//生成构造器函数public ThreadDemo2(String url, String name) {super();this.url = url;this.name = name;}//重写run方法@Overridepublic void run() {WebDownloader webDownloader=new WebDownloader();webDownloader.downloader(url, name);System.out.println("下载文件名："+name);}//main函数同时执行我们的run方法public static void main(String[] args) {ThreadDemo2 td1=new ThreadDemo2("https://img-blog.csdnimg.cn/527507fe3747495eac1332791f42b921.jpeg", "1.jpg");ThreadDemo2 td2=new ThreadDemo2("https://img-blog.csdnimg.cn/3d69d81d599c4c8f8c9eaf3b327dec8b.jpeg", "2.jpg");ThreadDemo2 td3=new ThreadDemo2("https://img-blog.csdnimg.cn/527507fe3747495eac1332791f42b921.jpeg", "3.jpg");td1.start();td2.start();td3.start();}
}
//第一要有一个下载器
class WebDownloader{//下载方法public void downloader(String url,String name) {try {FileUtils.copyURLToFile(new URL(url), new File(name));} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();System.out.println("IO异常，downloader方法出现问题");}}
}

2.3Runnable接口（重点）

定义MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

package com.study.Thread;import java.io.IOException;
import java.nio.CharBuffer;//创建线程方式2：定义MyRunnable类实现Runnable接口
//实现run()方法，编写线程执行体
//创建线程对象，调用start()方法启动线程
public class RunnableDemo implements Runnable {//run方法线程体public void run() {for(int i=0; i<20; i++) {System.out.println("我在看代码---"+i);}}//main线程，主线程public static void main(String[] args) {//创建Runnable接口的实现类对象RunnableDemo runnableDemo =new RunnableDemo();//创建一个线程对象，通过线程对象开启我们的线程，代理
//          Thread thread =new Thread(runnableDemo);
//          thread.start();//上面两句可以合并为new Thread(runnableDemo).start();//两条线程交替执行//只是运行速度快，我们感觉是同时执行for (int i = 0; i < 20; i++) {System.out.println("我在学习多线程---"+i);}}}

小结：

继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程:子类对象. start()
- 不建议使用:避免OOP单继承局限性

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

例子1：抢火车票

package com.study.Thread;import java.util.jar.Attributes.Name;/** 练习抢火车票* */
//发现问题：多个进程同时操作同一个资源，线程不安全，数据安全
public class RunnableDemo2  implements Runnable{//设置火车票数private int tickrtNums=10;@Overridepublic void run() {// TODO Auto-generated method stubwhile (true) {//设置一个无限循环if (tickrtNums<=0) {break;}//模拟延时try {Thread.sleep(200);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println(Thread.currentThread().getName()+"-->抢到了第"+tickrtNums--+"票");}//Thread.currentThread().getName()可以得到线程的名称}public static void main(String[] args) {RunnableDemo2 runnableDemo2=new RunnableDemo2();new Thread(runnableDemo2,"张三").start();new Thread(runnableDemo2,"李四").start();new Thread(runnableDemo2,"王五").start();new Thread(runnableDemo2,"黄牛").start();}
}

例子2：龟兔赛跑

package com.study.Thread;
/** 模拟龟兔赛跑* */
public class Race implements Runnable {//创建胜利者常量private static String winner;@Overridepublic void run() {// TODO Auto-generated method stubfor (int i = 0; i <= 100; i++) {//模拟兔子休息if (Thread.currentThread().getName().equals("兔子")&&i%10==0) {//判断那个线程是兔子,设置每10步休息一次try {Thread.sleep(1);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}//判断比赛结束没boolean flag=gameover(i);if (flag) {break;//flag为真，比赛结束}System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"米");}}//写判断是否完成比赛与得出谁是胜利者的一个方法private boolean gameover(int steps) {//传递一个步数参数//判断是否有胜利者if (winner!=null) {//已经存在胜利者return true;}else {if (steps>=100) {winner=Thread.currentThread().getName();//得到胜利者的名字System.out.println("我们的胜利者是："+winner);return true;}}return false;//都没有比赛继续}public static void main(String[] args) {Race race=new Race();//定义赛道new Thread(race,"兔子").start();new Thread(race,"乌龟").start();}
}

2.4实现Callable接口（了解）

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

Callable的好处：

可以定义返回值
可以抛出异常
有使用公式为上方加粗标红

package com.study.Thread;import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;import org.apache.commons.io.FileUtils;/** 线程创建方式三：实现Callable接口* */
public class CallableDemo implements Callable<Boolean> {private String url;//保存图片urlprivate String name;//保存图片名称//生成构造器函数public CallableDemo(String url, String name) {super();this.url = url;this.name = name;}//重写run方法@Overridepublic Boolean call() {WebDownloader webDownloader=new WebDownloader();webDownloader.downloader(url, name);System.out.println("下载文件名："+name);return true;}public static void main(String[] args) {CallableDemo td1=new CallableDemo("https://img-blog.csdnimg.cn/527507fe3747495eac1332791f42b921.jpeg", "1.jpg");CallableDemo td2=new CallableDemo("https://img-blog.csdnimg.cn/3d69d81d599c4c8f8c9eaf3b327dec8b.jpeg", "2.jpg");CallableDemo td3=new CallableDemo("https://img-blog.csdnimg.cn/527507fe3747495eac1332791f42b921.jpeg", "3.jpg");
//      创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(3);
//      提交执行 Future<Boolean> r1 = ser.submit(td1);Future<Boolean> r2 = ser.submit(td2);Future<Boolean> r3 = ser.submit(td3);
//      获取结果 try {boolean rs1 = r1.get();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (ExecutionException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {boolean rs2 = r2.get();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (ExecutionException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {boolean rs3 = r3.get();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (ExecutionException e) {// TODO Auto-generated catch blocke.printStackTrace();}
//      关闭服务 ser.shutdownNow();}
}
//这是从thread里面复制的，不在一个包里要加，在不需要
//第一要有一个下载器
//class WebDownloader{
//  //下载方法
//  public void downloader(String url,String name) {
//      try {
//          FileUtils.copyURLToFile(new URL(url), new File(name));
//      } catch (IOException e) {
//          // TODO Auto-generated catch block
//          e.printStackTrace();
//          System.out.println("IO异常，downloader方法出现问题");
//      }
//  }
//}

2.5静态代理模式

静态代理总结

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

好处：

代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情

package com.study.Thread;import java.lang.annotation.Target;
/** 静态代理总结* 真实对象和代理对象都要实现同一个接口* 代理对象要代理真实角色* 好处：* 代理对象可以做很多真实对象做不了的事情* 真实对象专注做自己的事情* */
public class StaticProxyDemo {public static void main(String[] args) {You you=new You();//WeddingCompany WeddingCompany=new WeddingCompany(you);//WeddingCompany.HappyMarry();可以简写为下面的形式new WeddingCompany(new You()).HappyMarry();new Thread(()->System.out.println("我爱你")).start();//lambda表达式}
}
//定义一个接口结婚
interface Marry{//人生四大喜事/** 久旱逢甘露* 他乡遇故知* 洞房花烛夜* 金榜题名时* */void HappyMarry();
}
//真实角色去结婚
class You implements Marry{@Overridepublic void HappyMarry() {// TODO Auto-generated method stubSystem.out.println("你结婚了很开心");}}
//代理角色，帮助你完成结婚
class WeddingCompany implements Marry{//代理谁-》真实的的目标角色private Marry target;//通过构造传递进来public WeddingCompany(Marry target) {super();this.target = target;}@Overridepublic void HappyMarry() {// TODO Auto-generated method stubbefore();//之前this.target.HappyMarry();//调用HappyMarry方法after();//之后}private void before() {// TODO Auto-generated method stubSystem.out.println("结婚之前，婚庆公司帮你布置现场");}private void after() {// TODO Auto-generated method stubSystem.out.println("结婚之后，婚庆公司找你收尾款");}}

2.6Lambda表达式

λ希腊字母表中排序第十一位的字母，英语名称为Lambda 入希腊字母表中排序第十一位的字母，英语名称为Lambda

为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让代码看起来更简洁
- 去掉无意义代码，留下核心逻辑
- 其实质属于函数编程的概念
- new Thread(()->System.out.println("我爱你")).start();//lambda表达式

注：只有一行代码的情况下才能简化成一行；前提是接口为函数式接口

理解Functional Interface(函数式接口）是学习Java8 lambda表达式的关键所在。
函数式接口的定义:
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

package com.study.Thread;
//使用Lambda表达式，可以是父类或者接口，里面只能有一个抽象方法
public class LambdaDemo2 {static class Love2 implements Ilove{@Overridepublic void love(String a) {// TODO Auto-generated method stubSystem.out.println("I Love You-->"+a);}}public static void main(String[] args) {//1.创建接口对象实现类Ilove ilove=new Love();ilove.love("创建接口对象实现类");//2.静态内部类实现ilove=new Love2();ilove.love("静态内部类实现");//3.内部类实现class Love3 implements Ilove{@Overridepublic void love(String a) {// TODO Auto-generated method stubSystem.out.println("I Love You-->"+a);}}ilove =new Love3();ilove.love("内部类实现");//4.局部内部类实现ilove=new Ilove() {@Overridepublic void love(String a) {// TODO Auto-generated method stubSystem.out.println("I Love You-->"+a);}};ilove.love("局部内部类实现");//5.使用lambda表达式实现ilove=(String a)->{System.out.println("I Love You-->"+a);};ilove.love("lambda表达式实现");//简化1.去掉参数返回类型ilove=(a)->{System.out.println("I Love You-->"+a);};ilove.love("lambda表达式简化1.去掉参数返回类型");//简化2.简化括号ilove=a->{System.out.println("I Love You-->"+a);};ilove.love("lambda表达式简化2.简化括号");//简化3.简化花括号ilove=a->System.out.println("I Love You-->"+a);ilove.love("lambda表达式简化3.简化花括号");/** 总结* lambda表达式只能在一行代码的情况下才能简化成为一行* 如果有多行就要用代码块包裹，就是花括号* 使用lambda表达式的前提是接口为函数式接口* 多个参数的也可以使用表达式，但是要去掉参数类型就都要去掉，* 不可以a没有类型，b有类型这个是不可以的* 二者都去掉参数类型才可以使用去掉括号的表达式* */}
}
//定义一个接口
interface Ilove{void love(String a);//里面只有一个抽象方法
}
//创建一个实现类
class Love implements Ilove{//@Overridepublic void love(String a) {// TODO Auto-generated method stubSystem.out.println("I Love You-->"+a);}}

3线程5种状态

线程的五种状态：

线程方法：

3.1线程停止——`stop()`

不推荐使用JDK提供的stop(); destroy();方法
推荐线程自己停止
建议使用一个标志位进行终止变量

package com.study.State;
/** 线程停止 * 1.建议线程正常停止-->利用次数，不建议死循环* 2.建议使用标志位-->设置标志位* 3.不要使用stop或者destroy等过时或者JDK不建议使用的方法* */
public class StopDemo implements Runnable{//设置一个标志位private boolean flag=true;@Overridepublic void run() {// TODO Auto-generated method stubint i=0;while (flag) {System.out.println("run...Thread"+i++);}}//设置一个公开的方法阻止线程，转换标志位public void stop() {this.flag=false;}public static void main(String[] args) {StopDemo stopDemo=new StopDemo();new Thread(stopDemo).start();for (int i = 0; i < 100; i++) {System.out.println("main执行了"+i+++"次");if (i==95) {//设置一个阈值，调用stop方法stopDemo.stop();System.out.println("线程结束");}}}
}

3.2线程休眠——`sleep()`

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

package com.study.State;import java.text.SimpleDateFormat;
import java.util.Date;/** 倒计时* */
public class SleepDemo2 {public static void main(String[] args) {
//      try {
//          tendown();
//      } catch (InterruptedException e) {
//          // TODO Auto-generated catch block
//          e.printStackTrace();
//      }Date date=new Date(System.currentTimeMillis());//获取当前世界while (true) {try {Thread.sleep(1000);System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));date=new Date(System.currentTimeMillis());} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}private static void tendown() throws InterruptedException {int num=10;while(true) {System.out.println(num--);Thread.sleep(1000);if (num==0) {break;}}}
}

3.3线程礼让——Yield()

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

package com.study.State;
/** 线程礼让* 礼让不一定成功，看CPU心情* */
public class YieldDemo {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()+"线程结束执行");}}

3.4线程强制执行——Join()

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

package com.study.State;
/** 线程强制执行* */
public class JionDemo implements Runnable {@Overridepublic void run() {// TODO Auto-generated method stubfor (int i = 0; i < 500; i++) {System.out.println("vip来了"+i);}}public static void main(String[] args) throws InterruptedException {//启动线程JionDemo jionDemo=new JionDemo();Thread thread =new Thread(jionDemo);thread.start();//主线程for (int i = 0; i < 1000; i++) {if (i==200) {thread.join();}System.out.println("main"+i);}}
}

3.5观测线程状态

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

package com.study.State;
/** 观察线程状态* */
public class StateDemo {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) {// TODO Auto-generated catch blocke.printStackTrace();}}System.out.println("线程结束");}); //观察状态Thread.State state=thread.getState();System.out.println(state);//new 创建状态//观察启动后thread.start();//让线程启动state=thread.getState();//更新现在的线程状态System.out.println(state);while (state!=Thread.State.TERMINATED) {//只要线程不终止，就一直输出状态Thread.sleep(100);state=thread.getState();//更新现在的线程状态System.out.println(state);}}
}

3.6.线程的优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，调度器按照优先级决定应该调度哪个线程来执行
线程的优先级用数字表示，范围从1~10
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
使用以下方式改变或获取优先级
- getPriority().setPriority(int xxx);

优先级低只是意味着获得调度的概率低，并不是高优先级必然先调用（性能倒置问题）

package com.study.Test;
/** 线程优先级* */
public class PriorityDemo {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);//代理Thread t5=new Thread(myPriority);//代理Thread t6=new Thread(myPriority);//代理//优先级要先设置，在启动否这没用t1.start();//不设置，直接启动t2.setPriority(1);//先设置优先级1t2.start();//再启动t3.setPriority(4);t3.start();t4.setPriority(Thread.MAX_PRIORITY);//设置为最高优先级t4.start();t5.setPriority(8);t5.start();t6.setPriority(7);t6.start();}
}
class MyPriority implements Runnable{@Overridepublic void run() {// TODO Auto-generated method stubSystem.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());//得到线程的名字和优先级}}

3.7守护线程——daemon

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

package com.study.State;
/** 守护线程* */
public class DaemonDemo {public static void main(String[] args) {Parent parent=new Parent();You you=new You();Thread thread=new Thread(parent);thread.setDaemon(true);//默认为false，表示为用户线程//正常的线程都是用户线程，为true时时守护线程thread.start();//守护线程启动new Thread(you).start();}
}
//国家
class Parent implements Runnable{@Overridepublic void run() {// TODO Auto-generated method stubwhile (true) {System.out.println("父母保护着你");}}
}
//你
class You implements Runnable{@Overridepublic void run() {// TODO Auto-generated method stubfor (int i = 0; i < 360; i++) {System.out.println("你在父母的保护下开心的活着");}System.out.println("===goodbye World====");}}

4.线程的同步

并发：同一个对象被多个线程同时操作

处理多线程问题时，多线程访问一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步。线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕再让下一个线程使用

线程同步：

由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性﹐在访问时加入锁机制synchronized ,当一个线程获得对象的排它锁,独占资源﹐其他线程必须等待，使用后释放锁即可．存在以下问题:

一个线程持有锁会导致其他所有需要此锁的线程挂起；
在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题；
如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置﹐引起性能问题。

4.1案例：不安全购票

package com.study.Synchronization;
/** 不安全的买票* 线程不安全 出现同时买到一张票* */
public class UnsafeBuyTicket {public static void main(String[] args) {BuyTicket station=new BuyTicket();//去车站买票new Thread(station,"张三").start();new Thread(station,"李四").start();new Thread(station,"王五").start();new Thread(station,"黄牛").start();}}class BuyTicket implements Runnable{private int ticket=10;//10张票boolean flag=true;//设置一个外部停止方式@Overridepublic void run() {// TODO Auto-generated method stub   while (flag) {try {buy();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}// 买票private void buy() throws InterruptedException {if (ticket<=0) {flag=false;//更新外部停止状态return;//没票卖完了}else {//模拟延时Thread.sleep(1000);System.out.println(Thread.currentThread().getName()+"买了"+ticket--);//买票}}
}

4.2案例：不安全取钱

package com.study.Synchronization;
/** 不安全的取钱* 两个人同时取钱* */
public class UnsafeBank {public static void main(String[] args) {Account account=new Account(100, "结婚基金");Drawing You =new Drawing(account, 50, "你");Drawing girlfriend =new Drawing(account, 100, "girlfriend");You.start();girlfriend.start();}
}
//账户
class Account {int money;//钱String name;//卡名public Account(int money, String name) {super();this.money = money;this.name = name;}
}
//银行模拟取款
class Drawing extends Thread{Account account;//账户int drawingMoney;//取了多少钱int nowMoney;//手里的钱public Drawing(Account account, int drawingMoney,String name) {super(name);this.account = account;this.drawingMoney = drawingMoney;}/* (non-Javadoc)* @see java.lang.Thread#run()*/@Override//开始取钱public void run() {if (account.money-drawingMoney<0) {//判断你可不可以取钱，你要取的钱超出账户余额System.out.println(Thread.currentThread().getName()+"卡内余额不足");return;}try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//取完钱后，更新账户余额account.money=account.money-drawingMoney;//取完钱后，现在手里一共多少钱nowMoney=drawingMoney+nowMoney;//取得钱+之前手里的钱System.out.println(account.name+"余额为："+account.money);//Thread.currentThread().getName()=this.getName()//Drawing继承了Thread的方法所以Thread.currentThread()等价于thisSystem.out.println(this.getName()+"手里的钱"+nowMoney);}}

4.3案例：不安全线程

package com.study.Synchronization;import java.util.ArrayList;
import java.util.List;/** 不安全线程的集合* */
public class UnsafeList {public static void main(String[] args) {List<String> list=new ArrayList<String>();for (int i = 0; i < 10000; i++) {new Thread(()->{list.add(Thread.currentThread().getName());}).start();}try {Thread.sleep(30000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println(list.size());}
}
package com.study.Synchronization;import java.util.ArrayList;
import java.util.List;/** 不安全线程的集合* */
public class UnsafeList {public static void main(String[] args) {List<String> list=new ArrayList<String>();for (int i = 0; i < 10000; i++) {new Thread(()->{list.add(Thread.currentThread().getName());}).start();}try {Thread.sleep(30000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println(list.size());}
}

4.4同步方法及同步块

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块

同步方法 public synchronized void method(int args){ }
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

同步方法的弊端：若将一个大的方法申明synchronized为将会影响效率

同步块:synchronized (Obj ){}
Obj称之为同步监视器
- 同步块:synchronized (Obj ){}Obj称之为同步监视器
- 同步方法中无需指定同步监视器﹐因为同步方法的同步监视器就是this ,就是这个对象本身，或者是class [反射中讲解]
同步监视器的执行过程
- 1.第一个线程访问,锁定同步监视器﹐执行其中代码．
- 2．第二个线程访问﹐发现同步监视器被锁定﹐无法访问．
- 3．第一个线程访问完毕﹐解锁同步监视器．
- 4．第二个线程访问,发现同步监视器没有锁﹐然后锁定并访问

package com.study.Synchronization;
/** 不安全的买票* 线程不安全 出现同时买到一张票* */
public class UnsafeBuyTicket {public static void main(String[] args) {BuyTicket station=new BuyTicket();//去车站买票new Thread(station,"张三").start();new Thread(station,"李四").start();new Thread(station,"王五").start();new Thread(station,"黄牛").start();}}class BuyTicket implements Runnable{private int ticket=10;//10张票boolean flag=true;//设置一个外部停止方式@Overridepublic void run() {// TODO Auto-generated method stub   while (flag) {try {buy();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}//synchronized同步方法，锁的是this// 买票private  synchronized void buy() throws InterruptedException {if (ticket<=0) {flag=false;//更新外部停止状态return;//没票卖完了}else {//模拟延时Thread.sleep(100);System.out.println(Thread.currentThread().getName()+"买了"+ticket--);//买票}}
}

package com.study.Synchronization;
/** 不安全的取钱* 两个人同时取钱* */
public class UnsafeBank {public static void main(String[] args) {Account account=new Account(300, "结婚基金");Drawing You =new Drawing(account, 50, "你");Drawing girlfriend =new Drawing(account, 100, "girlfriend");You.start();girlfriend.start();}
}
//账户
class Account {int money;//钱String name;//卡名public Account(int money, String name) {super();this.money = money;this.name = name;}
}
//银行模拟取款
class Drawing extends Thread{Account account;//账户int drawingMoney;//取了多少钱int nowMoney;//手里的钱public Drawing(Account account, int drawingMoney,String name) {super(name);this.account = account;this.drawingMoney = drawingMoney;}/* (non-Javadoc)* @see java.lang.Thread#run()*/@Override//开始取钱//synchronized, 默认锁的是this.//锁的对象是变化的量，需要增删改的对象public void run() {synchronized (account) {if (account.money-drawingMoney<0) {//判断你可不可以取钱，你要取的钱超出账户余额System.out.println(Thread.currentThread().getName()+"卡内余额不足");return;}try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//取完钱后，更新账户余额account.money=account.money-drawingMoney;//取完钱后，现在手里一共多少钱nowMoney=drawingMoney+nowMoney;//取得钱+之前手里的钱System.out.println(account.name+"余额为："+account.money);//Thread.currentThread().getName()=this.getName()//Drawing继承了Thread的方法所以Thread.currentThread()等价于thisSystem.out.println(this.getName()+"手里的钱"+nowMoney);}}}

package com.study.Synchronization;import java.util.ArrayList;
import java.util.List;/** 不安全线程的集合* */
public class UnsafeList {public static void main(String[] args) {List<String> list=new ArrayList<String>();for (int i = 0; i < 10000; i++) {new Thread(()->{synchronized (list) {list.add(Thread.currentThread().getName());}}).start();}try {Thread.sleep(3000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println(list.size());}
}

补充：CopyOnWriteArrayList

它相当于线程安全的ArrayList。和ArrayList一样，它是个可变数组；但是和ArrayList不同。效果于synchronized相同。

package com.study.Synchronization;import java.util.concurrent.CopyOnWriteArrayList;//测试JUC安全类型的集合
public class JUCDemo {public static void main(String[] args) {CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();for (int i = 0; i < 10000; i++) {new Thread(()->{list.add(Thread.currentThread().getName());}) .start();}try {Thread.sleep(3000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}

4.5死锁

多个线程各自占有一些共享资源﹐并且互相等待其他线程占有的资源才能运行﹐而导致两个或者多个线程都在等待对方释放资源﹐都停止执行的情形.某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。

死锁的避免方法：

产生死锁的四个必要条件
- 互斥：一个资源每次只能被一个进程使用
- 请求与保持：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺：进程已获得的资源，在未用完之前，不能强行剥夺
- 循环等待：若干进程之间形成一种头尾相接的循环等待资源关系

package com.study.Synchronization;
/** 死锁，多个线程互相抱着对方需要的资源，然后形成僵持的现象* 一个进程里不要同时操作两个以上的锁* */
public class LockDemo {public static void main(String[] args) {Makeup g1=new Makeup(0, "小红");Makeup g2=new Makeup(1, "小花");g1.start();g2.start();}
}
//口红
class Lipstick{}
//镜子
class mirror{}
class Makeup extends Thread{//所需的资源只有一份，用static来保证只有一份static Lipstick lipstick=new Lipstick();static mirror mirror=new mirror();int choice;//选择String girlName;// 使用化妆品的人public Makeup(int choice, String girlName) {super();this.choice = choice;this.girlName = girlName;}/* (non-Javadoc)* @see java.lang.Thread#run()*/@Override//使用化妆方法public void run() {// TODO Auto-generated method stubtry {makeup();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}//化妆方法//化妆，互相持有对方的锁，就是需要拿到对方的资源private void makeup () throws InterruptedException {if (choice==0) {synchronized (lipstick) {//获得口红的锁System.err.println(this.girlName+"拿到了口红");Thread.sleep(1000);//一秒后想拿到镜子/*会死锁的情况* synchronized (lipstick) {System.err.println(this.girlName+"拿到了口红");}* */}//要想不死锁，就不要抱着对方的锁synchronized (mirror) {System.err.println(this.girlName+"拿到了镜子");}}else {synchronized (mirror) {//获得镜子的锁System.err.println(this.girlName+"拿到了镜子");Thread.sleep(2000);//一秒后想拿到口红/*会死锁的情况* synchronized (lipstick) {System.err.println(this.girlName+"拿到了口红");}* */}synchronized (lipstick) {System.err.println(this.girlName+"拿到了口红");}}}
}

4.6lock锁

公式：

class A{private final ReentrantLock lock = new ReenTrantLock();public void m(){lock.lock();try{// 保证线程安全的代码}finally{lock.unlock();// 如果同步代码有异常，要将unlock()写入finally语句块 }}
}

案例：

package com.study.Synchronization;import java.util.concurrent.locks.ReentrantLock;/** Lock锁* */
public class LockDemo2 {public static void main(String[] args) {ticket ticket=new ticket();new Thread(ticket).start();new Thread(ticket).start();new Thread(ticket).start();}
}
class ticket implements Runnable {private int ticket=10;//10张票private final ReentrantLock lock=new ReentrantLock();@Overridepublic void run() {// TODO Auto-generated method stubwhile (true) {try {lock.lock();//加锁if (ticket>=0) {try {Thread.sleep(1000);System.out.println(ticket--);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}else {break;}} finally {// TODO: handle finally clause//解锁lock.unlock();}}}
}

synchronized 与Lock的对比

Lock是显示锁，需要手动开启和关闭，synchronized为隐式锁，出了作用域自动释放
lock只有代码块锁，synchronized有代码块锁和方法锁
使用lock锁，jvm将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性
优先使用顺序
- Lock > 同步代码快（已经进入方法体，分配了相应资源）> 同步方法(在方法体之外)

5.线程通信

线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，有需要马上通知消费者消费
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
在生产者消费者问题中，仅有synchronized是不够的
- synchronized可组织并发更新同一个共享资源，实现了同步
- synchronized不能用来实现不同线程之间的消息传递（通信）

Java提供了几个方法解决线程之间的通信问题

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，与sleep（）不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调度

注意： 均是Object类的方法，都只能在同步方法或者同步代码快中使用，否则会抛出异常 IllegalMonitorStateException

解决方法一：并发协作模型“生产者/消费者模式”--->管程法

生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
消费者：负责处理数据的模块（可能是方法、对象、线程、进程）
缓冲区：消费者不能直接使用生产者的数据，利用中间“缓冲区”

生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

package com.study.Resolvent;
/** 管程法* 生产者与消费者模型——>利用缓冲区解决* */
public class ProductionAndConsumption {public static void main(String[] args) {SyContainer syContainer=new SyContainer();new Production(syContainer).start();new Consumption(syContainer).start();}
}
//生产者
class Production extends Thread{SyContainer container;public Production(SyContainer container) {super();this.container = container;}/* (non-Javadoc)* @see java.lang.Thread#run()*/@Overridepublic void run() {// TODO Auto-generated method stubfor (int i = 0; i < 100; i++) {   container.push(new Chicken(i));System.out.println("生产了"+i+"只鸡");}}}
//消费者
class Consumption extends Thread{SyContainer container;public Consumption(SyContainer container) {super();this.container = container;}/* (non-Javadoc)* @see java.lang.Thread#run()*/@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("消费了-->"+container.pop().id+"只鸡");}}}
//产品
class Chicken{int id;public Chicken(int id) {super();this.id = id;}}
//缓冲区
class SyContainer{//需要一个容器，设置容器大小Chicken[] chickens=new Chicken[10];//对容器计数int count=0;//生产者存入产品public synchronized  Chicken push(Chicken chicken) {//如果容器满了，就需要等待消费者消费if (count==chickens.length) {//通知消费者消费，生产者等待try {this.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}//没有满，就在缓冲区丢入产品chickens[count]=chicken;count++;//可以通知消费者消费了this.notifyAll();return chicken;}public synchronized Chicken pop() {//判断是否能消费if (count==0) {//等待生产者生产，消费者等待try {this.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}//可以消费count--;Chicken chicken=chickens[count];//吃完了，通知生产者生产this.notifyAll();return chicken ;}
}

解决方法二：并发协作模型“生产者/消费者模式”--->信号灯法

package com.study.Resolvent;
/** 信号灯法* 通过设置标志位解决* */
public class SignalLamp {public static void main(String[] args) {TV tv = new TV();new Player(tv).start();new Watcher(tv).start();}
}// 生产者 --> 演员
class Player extends Thread{TV tv;public Player(TV tv){this.tv = tv;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {if (i % 2 == 0){//电视分为节目和广告this.tv.play("：新闻联播");}else{this.tv.play("整点报时");}}}
}
// 消费者 --> 观众
class Watcher extends Thread{TV tv;public Watcher(TV tv){this.tv = tv;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {tv.watch();}}
}// 产品 --> 节目
class TV{// 演员表演，观众等待 T// 观众观看，演员等待 FString voice; // 表演的节目boolean flag = true;// 表演public synchronized void play(String voice){//演员也要知道观众看完没if (!flag){//如果观众在观看，演员等待try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("演员表演了:" + voice);// 通知观众观看this.notifyAll(); // 通知唤醒this.voice = voice;//表演的节目刷新this.flag = !this.flag;//刷新标志位}// 观看public synchronized void watch(){if (flag){//演员再表演，观众等待try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("观看了：" + voice);// 通知演员表演this.notifyAll();this.flag = !this.flag;}
}

5.1线程池

package com.study.Resolvent;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/** 线程池* */
public class PoolDemo {public static void main(String[] args) {//1.创建范围，创建线程池ExecutorService service=Executors.newFixedThreadPool(10);//newFixedThreadPool(10);参数为：线程池大小//执行service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());//2.关闭服务service.shutdown();}
}
class MyThread implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}}

6总结

package Summary;import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;/** 总结* */
public class NEW {public static void main(String[] args) {new MyThread1().start();new Thread(new MyThread2()).start();FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());new Thread(futureTask).start();Integer integer;try {integer = futureTask.get();System.out.println(integer);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (ExecutionException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}// 1. 继承Thread类class MyThread1 extends Thread{@Overridepublic void run() {System.out.println("My Thread1");}}// 2. 实现Runnable接口class MyThread2 implements Runnable{@Overridepublic void run() {System.out.println("My Thread2");}}// 3. 实现Callable接口class MyThread3 implements Callable<Integer>{public Integer call() throws Exception {System.out.println("My Thread3");return 100;}
}

java笔记——多线程笔记相关推荐

java线程知乎_全网独家！知乎20K点赞的Java并发多线程笔记,简直堪称神仙级文档...
有很多小伙伴都问过我,头条号里的关于java多线程的文章有pdf版本吗?我其实很想弄pdf,但是前段时间一直没时间去折腾,我把每个Java并发编程核心技术的都整理成了一个又一个的文档.昨天也是终于全部 ...
0037 Java学习笔记-多线程-同步代码块、同步方法、同步锁
什么是同步在上一篇0036 Java学习笔记-多线程-创建线程的三种方式示例代码中,实现Runnable创建多条线程,输出中的结果中会有错误,比如一张票卖了两次,有的票没卖的情况,因为线程对象被多条 ...
11.1-全栈Java笔记:多线程技术的基本概念
多线程是JAVA语言的重要特性,大量应用于网络编程.应用于服务器端程序的开发.以及最常见的UI界面底层原理.操作系统底层原理都大量使用了多线程. 我们可以流畅的点击软件或者游戏中的各种按钮,其实,底层 ...
java基础巩固笔记(5)-多线程之线程并发库
2019独角兽企业重金招聘Python工程师标准>>> java基础巩固笔记(5)-多线程之线程并发库标签: java [TOC] 本文主要概述java.util.concurre ...
Java之多线程学习笔记五 —— 多线程模拟龟兔赛跑
Java之多线程学习笔记五 -- 多线程模拟龟兔赛跑参考教程B站狂神https://www.bilibili.com/video/BV1V4411p7EF package pers.ylw.less ...
Java学习笔记---多线程并发
Java学习笔记---多线程并发 (一)认识线程和进程 (二)java中实现多线程的三种手段 [1]在java中实现多线程操作有三种手段: [2]为什么更推荐使用Runnable接口? [3][补充知 ...
Java 多线程笔记转自http://www.cnblogs.com/lwbqqyumidi/p/3804883.html
多线程作为Java中很重要的一个知识点, 一.线程的生命周期及五种基本状态关于Java中线程的生命周期,首先看一下下面这张较为经典的图: 上图中基本上囊括了Java中多线程各重要知识点.掌握了上图中 ...
厚积薄发打卡Day25 ：狂神说Java之多线程详解＜全网最全(代码+笔记)＞
概述视频来源:[狂神说Java]多线程详解强烈推荐,
Java NIO 学习笔记（三）----Selector
目录: Java NIO 学习笔记(一)----概述,Channel/Buffer Java NIO 学习笔记(二)----聚集和分散,通道到通道 Java NIO 学习笔记(三)----Select ...

java笔记——多线程笔记

学习目标：

1.线程简介

普通方法调用和多线程的区别

Process（进程）与Thread（线程）

本章核心概念

2.线程创建

2.1 三种创建方式

2.2Thread（重点）

2.3Runnable接口（重点）

例子1：抢火车票

例子2：龟兔赛跑

2.4实现Callable接口（了解）

2.5静态代理模式

2.6Lambda表达式

3线程5种状态

3.1线程停止——`stop()`

3.2线程休眠——`sleep()`

3.3线程礼让——Yield()

3.4线程强制执行——Join()

3.5观测线程状态

3.6.线程的优先级

3.7守护线程——daemon

4.线程的同步

4.1案例：不安全购票

4.4同步方法及同步块

补充：CopyOnWriteArrayList

4.5死锁

4.6lock锁

synchronized 与Lock的对比

5.线程通信

解决方法一：并发协作模型“生产者/消费者模式”--->管程法

解决方法二：并发协作模型“生产者/消费者模式”--->信号灯法

5.1线程池

6总结

java笔记——多线程笔记相关推荐

最新文章

热门文章