多线程学习

最新推荐文章于 2024-08-15 14:47:41 发布

Brandon522

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量117

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_50310965/article/details/120090785

版权

线程实现、线程同步是重点！

进程Process与线程Thread

进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。

通常在一个进程中可以包含若干个线程，一个进程至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

核心概念：

1.在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程。

2.main()称之为主线程，为系统的入口，用于执行整个程序。

3.在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。

4.对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。

5.线程会带来额外的开销，如cpu调度时间，并发控制开销。

6.每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

7.线程是独立的执行路径。

线程创建（重点）

三种创建方式：

1.Thread class：继承Thread类

2.Runnable接口：实现Runnable接口

3.Callable接口：实现Callable接口（了解）

Thread

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

调用run()，只有主线程一条执行路径！（主线程调用run()）等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。
调用start()，多条执行路径，主线程和子线程并行交替执行（子线程调用run()）！

 //创建线程方式一
 public class TestThread1 extends Thread{
     @Override
     public void run(){
         //run方法线程体
         for(int i = 0; i < 200; i++){
             System.out.printIn("我在看代码" + i);
         }
     }
     
     public static void main(String[] args){
         //main线程，主线程
         
         //创建一个线程对象
         TestThread1 testThread1 = new TestThread1();
         
         //调用start()方法开启线程
         testThread1.start();
         
         for(int i = 0; i < 2000; i++){
             System.out.printIn("我在学习进程" + i);
         }
     }
 } //两个输出交替执行，并不是同时进行

总结：线程开启不一定立即执行，由CPU调度执行！

多线程实现网图下载（Thread）

 //练习Thread，实现多线程下载图片
 import org.apache.commons.io.FileUtils;
 
 public class TestThread2 extends Thread{
 
     private String url;
     private String name;
     
     public TestThread2(String url,String name){
         this.url = url;
         this.name = name;
     }
     
     //下载图片线程的执行体
     @Override
     public void run(){
         WebDownloader webDownloader = new WebDownloader();
         webDownloader.downloader(url, name);
         System.out.println("下载了文件名为:" + name);
     }
     
     public static void main(String[] args){
         TestThread2 t1 = new TestThread2("url1", "1.jpg");
         TestThread2 t2 = new TestThread2("url2", "2.jpg");
         TestThread2 t3 = new TestThread2("url1", "3.jpg");
         
         t1.start();
         t2.start();
         t3.start();
         //结果，输出顺序不一定
         //下载了文件名:3.jpg
         //下载了文件名:1.jpg
         //下载了文件名:2.jpg
     }
 
 }
 
 //下载器
 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接口

1.定义MyRunnable类实现Runnable接口

2.实现run()方法，编写线程执行体

3.创建线程对象，调用start()方法启动线程

 //创建线程方式2
 public class TestThread3 implements Runnable{
     @Override
     public void run(){
         //run方法线程体
         for(int i = 0; i < 200; i++){
             System.out.printIn("我在看代码" + i);
         }
     }
     
     public static void main(String[] args){
         //创建runnable接口的实现类对象
         TestThread3 testThread3 = new TestThread3();
         
         //创建线程对象，通过线程对象来开启我们的线程（代理）
         
         //Thread thread = new Thread(testThread3);
         //thread.start();
         
         new Thread(testThread3).start();  //就这里和创建线程方法1有区别，多用了代理
         
         for(int i = 0; i < 1000; i++){
             System.out.println("我在学习多线程" + i);
         }
     }
 }

小结（Thread、Runnable比较）：

1.继承Thread类

(1)子类继承Thread类具备多线程能力

(2)启动线程：子类对象.start()

(3)不建议使用:避免OOP单继承局限性

2.实现Runnable接口

(1)实现接口Runnable具有多线程能力

(2)启动线程：传入目标对象 + Thread对象.start()

(3)推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。（一份资源多个代理）

初识并发问题

 //多个线程同时操作同一个对象
 //买火车票的例子
 public class TestThread4 implements Runnable{
     
     //票数
     private int ticketNums = 10;
     
     @Override
     public 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){
         
         TestThread4 ticket = new TestThread4();
         
         new Thread(ticket, "小明").start();
         new Thread(ticket, "老师").start();
         new Thread(ticket, "黄牛").start();
     }
 }
 
 //小明-->拿到第10票
 //老师-->拿到第8票
 //黄牛-->拿到第9票
 //黄牛-->拿到第7票
 //老师-->拿到第7票
 //小明-->拿到第7票
 //小明-->拿到第5票
 //老师-->拿到第6票
 //黄牛-->拿到第4票
 //黄牛-->拿到第3票
 //小明-->拿到第2票
 //老师-->拿到第3票
 //黄牛-->拿到第1票
 //小明-->拿到第-1票
 //老师-->拿到第0票

发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。（线程并发问题）

实现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接口
 public class TestCallable implements Callable<Boolean>{ //返回值类型和call方法中返回值类型相同
 
     private String url;
     private String name;
     
     public TestThread2(String url,String name){
         this.url = url;
         this.name = name;
     }
     
     //下载图片线程的执行体
     @Override
     public Boolean call(){
         WebDownloader webDownloader = new WebDownloader();
         webDownloader.downloader(url, name);
         System.out.println("下载了文件名为:" + name);
         return true;
     }
     
     public static void main(String[] args){
         TestCallable t1 = new TestCallable("url1", "1.jpg");
         TestCallable t2 = new TestCallable("url2", "2.jpg");
         TestCallable t3 = new TestCallable("url1", "3.jpg");
         
         //创建执行服务：（需要创建三个线程）
         ExecutorService ser = Executors.newFixedThreadPool(3);
         //提交执行
         Future<Boolean> r1 = ser.submit(t1);
         Future<Boolean> r2 = ser.submit(t2);
         Future<Boolean> r3 = ser.submit(t3);
         //获取结果
         boolean rs1 = r1.get();
         boolean rs2 = r2.get();
         boolean rs3 = r3.get();
         //关闭服务
         ser.shutdownNow();
     }
 
 }
 
 //下载器
 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方法出现问题");
         }
     }
 }

callable的好处：

1.可以定义返回值

2.可以抛出异常

静态代理模式（重点，设计模式之一）

 public class StacticProxy{
     public static void main(String[] args){
         
         //很重要！！！
         //new Thread( ()-> System.out.println("我爱你") ).start();
         //new WeddingCompany(new You()).HappyMarry();  相当于下面两句
         //多线程与第五行进行比较，Thread和WeddingCompany都是代理，对括号的对象进行代理
         //都实现了Runnable接口，Thread和Runnable都有run方法,start方法是Thread所做的
         
         
         
         WeddingCompany weddingCompany = new WeddingCompany(new you());
         weddingCompany.HappyMarry();
         //输出  结婚前...    结婚超开心    结婚后...
     }
 }
 
 
 interface Marry{
     void HappyMarry;
 }
 
 //真实角色，你去结婚
 class You implements Marry{
     @Override
     public void HappyMarry(){
         System.out.print("老师要结婚了，超开心！")
     }
 }
 
 //代理角色，帮助你结婚
 class WeddingCompany implements Marry{
     
     //代理谁 --> 真实目标角色
     private Marry target;
     
     public WeddingCompany(Marry target){
         this.target = target;
     }
     
     @Override
     public void HappyMarry(){
         before();
         this.target.HappyMarry();  //这就是真实对象
         after();
     }
     
     private void before(){
         System.out.println("结婚之前，布置现场");
     }
     private void after(){
         System.out.println("结婚之后，收尾款");
     }
 }

静态代理模式总结：

1.真实对象和代理对象都要实现同一个接口

2.代理对象要代理真实角色

好处：

1.代理对象可以做很多真实对象做不了的事情

2.真实对象专注做自己的事情

Lamda表达式

其实质属于函数式编程的概念
为什么要用lambda表达式

1.避免匿名内部类定义过多

2.可以让你的代码看起来很简洁

3.去掉一些没有意义的代码，只留下核心的逻辑

函数式接口的定义

1.任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

 public interface Runnable{
     public abstract void run();
 }

2.对于函数式接口，我们可以通过lamda表达式来创建该接口的对象

 //推导lamda表达式
 public class TestLamda1{
     
     //3.静态内部类
     public class Like2 implements ILike{
         @Override
         public void lamda(){
             System.out.println("I like lamda2");
         }
     }
     
     public static void main(String[] args){
         ILike like = new Like();
         like.lamda(); //输出I like lamda1
         
         ILike like = new Like2();
         like.lamda(); //输出I like lamda2
         
         //4.局部内部类
         class Like3 implements ILike{
             @Override
             public void lamda(){
                 System.out.println("I like lamda3");
             }
         }
         
         ILike like = new Like3();
         like.lamda(); //输出I like lamda3
         
         //5.匿名内部类，没有类的名称，必须借助接口或父类
         like = new ILike(){
             @Override
             public void lamda(){
                 System.out.println("I like lamda4");
             }
         }
         like.lamda(); //输出I like lamda4
         
         //6.用lamda简化
         ILike like = ()->{
             System.out.println("I like lamda5");
         }
         like.lamda(); //输出I like lamda5
     }
     }
     
 }
 
 //1.定义一个函数式接口
 interface ILike{
     void lamda();  //抽象方法
 }
 
 //2.实现类
 class Like implements ILike{
     @Override
     public void lamda(){
         System.out.println("I like lamda");
     }
 }

lamda表达式简化

 public class TestLamda2{
     //1.lamda表达式简化
     ILove love = (int a)->{
         System.out.println("i love you -->" + a);
     }
     
     //简化1：参数类型
     ILove love = (a)->{
         System.out.println("i love you -->" + a);
     }
     
     //简化2：简化括号
      ILove love = a->{
         System.out.println("i love you -->" + a);
     }
     
     //简化3：去掉花括号
     ILove love = a-> System.out.println("i love you -->" + a);
     
     love.love(521);
     
     //总结:
     //1.lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行，就用代码块包裹
     //2.前提是接口为函数式接口
     //3.多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号
 }
 
 interface ILove{
     void love(int a);
 }

Runnable接口中只有一个抽象的run()方法

线程状态及方法

线程方法

停止线程

1.不推荐使用JDK提供的stop()、destroy()方法。（已废弃）

2.推荐线程自己停下来 -->利用次数，不建议死循环

3.建议使用一个标志位进行终止变量，当flag=false，则终止线程运行

 public class TestStop implements Runnable{
     //1.设置一个标志位
     private boolean flag = true;
     
     @Override
     public 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){
                 //调用stop方法切换标志位，让线程停止
                 testStop.stop();
                 System.out.println("线程该停止了");
             }
         }
         
     }
 }

线程休眠(sleep)

1.sleep(时间)指定当前线程阻塞的毫秒数

2.sleep存在异常InterruptedException

3.sleep时间达到后线程进入就绪状态

4.sleep可以模拟网络延时，倒计时等

5.每一个对象都有一个锁，sleep不会释放锁

模拟网络延时：放大问题的发生性

 //模拟倒计时
 public class TestSleep2{
     public static void main(String[] args){
         try{
             tenDown(); //静态方法，直接调用
         }catch(InterruptedException e){
             e.printStackTrace();
         }
     }
     
     public static void tenDown() throws InterruptedException{
         int num = 10;
         while(true){
             Thread.sleep(1000);
             System.out.println(num--);
             if(num<=0){
                 break;
             }
         }
     }
 }

线程礼让（yield）

1.礼让线程，让当前正在执行的线程暂停，但不阻塞

2.将线程从运行状态转换为就绪状态

3.让cpu重新调度（重新竞争），礼让不一定成功！看CPU心情

 public class TestYield{
     public static void main(String[] args){
         MyYield myYield = new MyYield();
         
         new Thread(myYield,"a").start();
         new Thread(myYield,"b").start();
     }
 }
 
 class MyYield implements Runnable{
     @Override
     public void run(){
         System.out.println(Thread.currentThread().getName()+"线程开始执行");
         Thread.yield(); //礼让
         System.out.println(Thread.currentThread().getName()+"线程停止执行");
     }
 }
 //礼让不一定成功！
 //没礼让成功的话就是打印同一个线程开始线程然后停止，礼让成功的话就a线程开始执行之后b线程就开始了

线程强制执行（join）

1.join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

2.可以想象成插队

 public class TestJoin implements Runnable{
     @Override
     public void run(){
         //100.for可快速出来(IDEA)
         for(int i = 0; i < 500; i++){
             System.out.println("线程vip来了" + i);
         }
     }
     
     public static void main(String[] args) throws InterruptedException{
         //启动我们的线程
         TestJoin testJoin = new TestJoin();
         Thread thread = new Thread(testJoin);
         thread.start();
         
         //主线程
         for(int i = 0; i < 1000; i++){
             if(i==200){
                 thread.join(); //插队
             }
             System.out.println("main"+i);
         }
     }
 }
 //结果，先是两个线程交替执行，到200的时候子线程开始执行一直到结束，才开始主线程的执行

线程状态观测

Thread.State

 //观测线程状态
 public class TestState {
     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);
 
         //观察启动后
         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
 //  ......
 //TIMED_WAITING
 // /
 //TERMINATED

线程优先级

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

线程的优先级用数字来表示，范围从1~10.

(1)Thread.MIN_PRIORITY = 1;

(2)Thread.MAX_PRIORITY = 10;

(3)Thread.NORM_PRIORITY = 5;

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

 //测试线程的优先级
 public class TestPriority{
     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);
         t4.start();
     }
 }
 
 class MyPriority implements Runnable{
 
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
     }
 }

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU调度。

守护（daemon）线程

1.线程分为用户线程和守护线程（唯一的区别就是JVM何时离开）

2.虚拟机必须确保用户线程执行完毕

3.虚拟机不用等待守护线程执行完毕

4.如：后台记录操作日志，监控内存，垃圾回收等待..

main()就相当于用户线程，gc()相当于守护线程（垃圾回收线程）

 //测试守护线程
 public class TestDaemon {
     public static void main(String[] args) {
         God god = new God();
         You you = new You();
 
         Thread thread = new Thread(god);
         thread.setDaemon(true);  //设置为守护线程，默认是false表示是用户线程，正常的线程都是用户线程
 
         thread.start(); //上帝守护线程启动
 
         new Thread(you).start(); //你 用户线程启动
     }
 }
 
 //上帝
 class God implements Runnable{
 
     @Override
     public void run() {
         while (true){
             System.out.println("上帝保佑着你");
         }
     }
 }
 
 //你
 class You implements Runnable{
 
     @Override
     public void run() {
         for (int i = 0; i < 36500; i++) {
             System.out.println("你一生都开心的活着");
         }
         System.out.println("====goodbye!world!====");
     }
 }
 
 //结果用户线程结束之后，JVM停止，相当于守护线程也结束了

线程同步（重点）

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

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

线程同步的形成条件：队列+锁

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

（1）一个线程持有锁会导致其他所有需要此锁的线程挂起

（2）在多个线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题

（3）如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

不安全案例

 //不安全的买票
 //线程不安全，有负数
 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();
     }
 }
 
 class BuyTicket implements Runnable{
 
     //票
     private int ticketNums = 10;
     boolean flag = true; //外部停止方式
 
     @Override
     public void run() {
         //买票
         while (flag){
             try {
                 buy();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 
     private void buy() throws InterruptedException {
         //判断是否有票
         if(ticketNums<=0){
             flag = false;
             return;
         }
 
         //模拟延时
         Thread.sleep(100);
 
         //买票
         System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
     }
 }
 //结果
 //苦逼的我拿到10
 //可恶的黄牛党拿到9
 //牛逼的你们拿到8
 //苦逼的我拿到7
 //牛逼的你们拿到5
 //可恶的黄牛党拿到6
 //苦逼的我拿到4
 //可恶的黄牛党拿到3
 //牛逼的你们拿到2
 //苦逼的我拿到1
 //牛逼的你们拿到0
 //可恶的黄牛党拿到-1

 //不安全案例2
 //不安全的取钱
 //两个人去银行取钱，账户
 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){
         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;
     }
 
     @Override
     public void run() {
         //判断有没有钱
         if(account.money-drawingMoney<0){
             System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
             return;
         }
 
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
         //卡内余额 = 余额 - 你取的钱
         account.money = account.money - drawingMoney;
         //你手里的钱
         nowMoney = nowMoney + drawingMoney;
 
         System.out.println(account.name + "余额为" + account.money);
         //Thread.currentThread().getName() = this.getName();
         System.out.println(this.getName() + "手里的钱:" + nowMoney);
     }
 }
 //结婚基金余额为50
 //你手里的钱:50
 //结婚基金余额为-50
 //girlFriend手里的钱:100

 //不安全案例3
 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(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(list.size());
     }
 }
 //可能多个线程同时进行无法添加满
 //结果输出list大小小于10000

同步方法

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

 //同步方法
 public synchronized void method(int args){}

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

缺陷：若将一个大的方法声明为synchronized将会影响效率。

方法里需要修改的内容才需要锁，锁的太多，浪费资源
synchronized默认锁的是this本身

同步块

同步块：synchronized (Obj) {}

Obj 称之为 同步监视器

1.Obj可以是任何对象，但是推荐使用共享资源作为同步监视器

2.同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本市，或者是class（反射中讲解）

同步监视器的执行过程

1.第一个线程访问，锁定同步监视器，执行其中代码

2.第二个线程访问，发现同步监视器被锁定，无法访问

3.第一个线程访问完毕，解锁同步监视器

4.第一个线程访问。发现同步监视器没有锁，然后锁定访问

synchronized (需要锁的对象) {把所有代码复制到该代码块中}

比如两个人同时取银行里同一个账户的例子，Account 声明的account对象是两个线程共有的，run方法是两个对象独有的，所以锁run方法就是各锁各的。（account是两个人共有的Account的对象）

上面不安全案例的修改!

 //案例1修改
 //不安全的买票
 //线程不安全，有负数
 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();
     }
 }
 
 class BuyTicket implements Runnable{
 
     //票
     private int ticketNums = 10;
     boolean flag = true; //外部停止方式
 
     @Override
     public void run() {
         //买票
         while (flag){
             try {
                 //模拟延时，要在synchronized方法外面，否则全被第一个人拿走
                 Thread.sleep(100);
 
                 buy();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 
     //修改的地方！
     //synchronized 同步方法，对象是BugTicket，锁的是this
     private synchronized void buy() throws InterruptedException {
         //判断是否有票
         if(ticketNums<=0){
             flag = false;
             return;
         }
 
         //买票
         System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
     }
 }
 //结果
 //牛逼的你们拿到10
 //苦逼的我拿到9
 //可恶的黄牛党拿到8
 //牛逼的你们拿到7
 //苦逼的我拿到6
 //可恶的黄牛党拿到5
 //可恶的黄牛党拿到4
 //苦逼的我拿到3
 //牛逼的你们拿到2
 //可恶的黄牛党拿到1

 //案例二修改
 //不安全的取钱
 //两个人去银行取钱，账户
 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){
         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;
     }
 
     @Override
     public void run() {
 
         //修改的地方！
         synchronized (account){
             //判断有没有钱
             if(account.money-drawingMoney<0){
                 System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                 return;
             }
 
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
 
             //卡内余额 = 余额 - 你取的钱
             account.money = account.money - drawingMoney;
             //你手里的钱
             nowMoney = nowMoney + drawingMoney;
 
             System.out.println(account.name + "余额为" + account.money);
             //Thread.currentThread().getName() = this.getName();
             System.out.println(this.getName() + "手里的钱:" + nowMoney);
         }
 
     }
 }
 //结果：
 //结婚基金余额为50
 //你手里的钱:50
 //girlFriend钱不够，取不了

Account 声明的account对象是两个线程共有的，run方法是两个对象独有的，所以锁run方法就是各锁各的，应该锁account。（account是两个人共有的Account的对象）

 //修改案例3
 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
                 synchronized (list){
                     list.add(Thread.currentThread().getName());
                 }
             }).start();
         }
         //增加睡眠，防止数组还没有添加完就执行主线程的打印操作
         try {
             Thread.sleep(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(list.size());
     }
 }
 //可能多个线程同时进行无法添加满
 //结果输出list大小等于10000

CopyOnWriteArrayList(线程安全)

该类是JUC安全类型的集合。

 import java.util.concurrent.CopyOnWriteArrayList;
 
 //测试JUC安全类型的集合!
 public class TestJUC {
     public static void main(String[] args) {
         //这个类本来就是安全的，不需要用synchronized关键字锁住（与上面不安全案例3有区别）
         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) {
             e.printStackTrace();
         }
 
         System.out.println(list.size());
     }
 }

死锁

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

产生死锁的四个必要条件：

1.互斥条件：一个资源只能被一个进程使用。

2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。

4.循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

以上的四个必要条件，我们只要想办法破坏以上的任意一个或多个条件就可以避免死锁的发生。

 //死锁：多个线程相互抱着对方需要的资源，然后形成僵持
 public class DeadLock {
     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; //使用化妆品的人
 
     Makeup(int choice, String girlName){
         this.choice = choice;
         this.girlName = girlName;
     }
 
     @Override
     public void run() {
         //化妆
         try {
             makeup();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 
     //化妆，相互持有对方的锁，就是需要拿到对方的资源
     private void makeup() throws InterruptedException{
         if(choice == 0){
             synchronized (lipstick){//获得口红的锁
                 System.out.println(this.girlName+"获得口红的锁");
                 Thread.sleep(1000);
                 synchronized (mirror){//一秒钟后想获得镜子
                     System.out.println(this.girlName+"获得镜子的锁");
                 }
             }
         }else{
             synchronized (mirror) {//获得镜子的锁
                 System.out.println(this.girlName + "获得镜子的锁");
                 Thread.sleep(2000);
                 synchronized (lipstick) {//两秒钟后想获得镜子
                     System.out.println(this.girlName + "获得口红的锁");
                 }
             }
         }
     }
 }
 //结果
 //灰姑娘获得口红的锁
 //白雪公主获得镜子的锁
 //程序停止不了

可以将最里面的synchronized语句提到与外面同一层即可不产生死锁(如下)

 synchronized (mirror) {//获得镜子的锁
     System.out.println(this.girlName + "获得镜子的锁");
     Thread.sleep(2000);
 }
 synchronized (lipstick) {//两秒钟后想获得镜子
     System.out.println(this.girlName + "获得口红的锁");
 }

Lock锁

从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义锁对象来实现同步。同步锁使用Lock对象充当。（synchronized是隐式锁）

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象。
ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

规范：

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

例子

 import java.util.concurrent.locks.ReentrantLock;
 
 //测试Lock锁
 public class TestLock {
     public static void main(String[] args) {
         TestLock2 testLock2 = new TestLock2();
 
         new Thread(testLock2).start();
         new Thread(testLock2).start();
         new Thread(testLock2).start();
     }
 }
 
 class TestLock2 implements Runnable{
     int ticketNums = 10;
 
     //定义lock锁
     private final ReentrantLock lock = new ReentrantLock();
 
     @Override
     public void run() {
         while(true){
             try{
                 lock.lock(); //加锁,放入try-catch中
                 if(ticketNums>0){
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println(ticketNums--);
                 }else{
                     break;
                 }
             }finally {
                 lock.unlock(); //解锁
             }
 
 
         }
     }
 }
 
 //有序输出10,9,8，...，1

synchronized与Lock的对比

1.Lock是显示锁（手动开启和关闭锁），synchronized是隐式锁，除了作用域自动释放

2.Lock只有代码块锁，synchronized有代码块锁和方法锁

3.使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有很好的扩展性（提供更多的子类）

4.优先使用顺序：

Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）

线程协作（生产者消费者模式）

应用场景：生产者消费者问题

（1）假设仓库只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费

（2）如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，知道仓库中的产品被消费者取走为止。

（3）如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

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

对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又要马上通知消费者消费。
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
在生产者消费者问题中，仅有synchronized是不够的

1.synchronized可阻止并发更新同一个共享资源，实现了同步

2.synchronized不能用来实现不同线程之间的消息传递(通信)

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

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

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

解决方法1（管程法）

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

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

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

生产者 ------> 缓冲区 ------> 消费者

 //测试：生产者消费者模型 --> 利用缓冲区解决：管程法
 
 //生产者，消费者，产品，缓冲区
 public class TestPC {
     public static void main(String[] args) {
         SynContainer container = new SynContainer();
 
         new Productor(container).start();
         new Consumer(container).start();
     }
 }
 
 //生产者
 class Productor extends Thread{
     SynContainer container;
     public Productor(SynContainer container){
         this.container = container;
     }
 
     //生产
     @Override
     public void run() {
         for (int i = 0; i < 100; i++) {
             container.push(new Chicken(i));
             System.out.println("生产了"+i+"只鸡");
         }
     }
 }
 
 //消费者
 class Consumer extends Thread{
     SynContainer container;
     public Consumer(SynContainer container){
         this.container = container;
     }
 
     //消费
     @Override
     public void run() {
         for (int i = 0; i < 100; i++) {
             System.out.println("消费了"+container.pop().id+"只鸡");
         }
     }
 }
 
 //产品
 class Chicken{
     int id; //产品编号
 
     public Chicken(int id){
         this.id = id;
     }
 }
 
 //缓冲区
 class SynContainer{
     //需要一个容器大小
     Chicken[] chickens = new Chicken[10];
     //容器计数器
     int count = 0;
 
     //生产者放入产品,synchronized
     public synchronized void push(Chicken chicken){
         //如果容器满了，就需要等待消费者消费
         if(count==chickens.length){
             //通知消费者消费，生产等待
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
 
         //如果没有满，我们就需要丢入产品
         chickens[count]=chicken;
         count++;
 
         //可以通知消费者消费了
         this.notifyAll();
     }
 
     //消费者消费产品,synchronized
     public synchronized Chicken pop(){
         //判断能否消费
         if(count==0){
             //等待生产者生产，消费者等待
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
 
         //如果可以消费
         count--;
         Chicken chicken = chickens[count];
 
         //吃完了，通知生产者生产
         this.notifyAll();
         return chicken;
     }
 }

解决方法2（信号灯法）

并发协作模型“生产者/消费者模式” --> 信号灯法（flag标志位来判断等待还是通知）

 //测试生产者消费者问题2：信号灯法，标志位解决
 public class TestPC2 {
     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;
     }
 
     @Override
     public 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;
     }
 
     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {
             tv.watch();
         }
     }
 }
 
 //产品-->节目
 class TV{
     //演员表演，观众等待 T
     //观众观看，演员等待 F
     String 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;
     }
 }
 //演员表演了快乐大本营
 //观看了快乐大本营
 //演员表演了抖音
 //观看了抖音
 //演员表演了快乐大本营
 //观看了快乐大本营
 //演员表演了抖音
 //观看了抖音

线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：

1.提高响应速度（减少了创建新线程的时间）

2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）

3.便于线程管理(..)

(1)corePoolSize：核心池的大小

(2)maximumPoolSize：最大线程数

(3)keepAliveTime：线程没有任务时最多保持多长时间后会终止

JDK5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

(1)void execute(Runnable command)：执行任务/命令，没有返回值。一般用来执行Runnable

(2)<T>Future<T> sunbmit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable

(3)void shutdown()：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 //测试线程池
 public class TestPool {
     public static void main(String[] args) {
         //1.创建服务，创建线程池
         //ExecutorService真正的线程池接口
         //newFixedThreadPool 参数为线程池的大小
         ExecutorService service = Executors.newFixedThreadPool(10);
 
         //2.执行
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
 
         //3.关闭连接
         service.shutdown();
     }
 }
 
 class MyThread implements Runnable{
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName());
     }
 }
 //输出结果
 //pool-1-thread-1
 //pool-1-thread-4
 //pool-1-thread-3
 //pool-1-thread-2

总结

 import com.sun.deploy.net.proxy.ProxyUnavailableException;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
 
 //回顾总结线程的创建
 public class ThreadNew {
     public static void main(String[] args) {
         //1.继承Thread类
         new MyThread1().start();
 
         //2.实现Runnable接口
         new Thread(new MyThread2()).start();
 
         //3.实现Callable接口，这个跟之前用的不一样
         FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
         new Thread(futureTask).start();
 
         try {
             Integer integer = futureTask.get();
             System.out.println(integer);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
 }
 
 //1.继承Thread类
 class MyThread1 extends Thread{
     @Override
     public void run() {
         System.out.println("MyThread1");
     }
 }
 
 //2.实现Runnable接口
 class MyThread2 implements Runnable{
     @Override
     public void run() {
         System.out.println("MyThread2");
     }
 }
 
 //3.实现Callable接口
 class MyThread3 implements Callable<Integer>{ //需要返回值
     @Override
     public Integer call() throws Exception { //注意这里是重写call方法
         System.out.println("MyThread3");
         return 100;
     }
 }

Brandon522

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程学习

线程实现、线程同步是重点！进程Process与线程Thread进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。通常在一个进程中可以包含若干个线程，一个进程至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。核心概念： 1.在程..
复制链接

扫一扫