多线程笔记

已于 2023-07-18 19:45:23 修改
阅读量106 收藏
点赞数
文章标签： 笔记 开发语言 java
于 2023-07-18 19:34:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64633307/article/details/131794718
版权

多线程

一.进程与线程

1.进程

​ 操作系统中的最小单位，通过进程可以创建程序的应用。

2.线程

​ 线程是进程中的最小单位，一个进程中可以包含多个线程，并且可以同时执行，此时就形成了多线程状态。

3.并发与并行

​ 例子图：
在这里插入图片描述

​ 并发：是指两个队列交替的在一台咖啡机上接咖啡

​ 并行: 是指两个队列在两台咖啡机排队接咖啡

​ 串行: 只有一个队列，挨个接咖啡。

4.多线程

4.1 多线程的概念

在Java中，多线程是指程序中同时执行多个线程的能力。位，一个进程可以包含多个线程。使用多线程可以让程序在同一时间内执行多个任务，从而提高程线程是计算机执行代码的最小单序的执行效率。

4.2 多线程的好处

使用多线程有以下几个好处：

  1. 提高程序的执行效率：通过多线程，可以让程序同时执行多个任务，利用多核处理器的并行计算能力，从而提高程序的整体执行效率。多线程可以使程序在某些情况下快速响应用户操作，提高用户体验。

  2. 充分利用 CPU 时间片：在单线程环境下，当一个线程的任务没有执行完毕时，CPU 会一直等待，导致 CPU 时间片的浪费。而多线程可以让不同的线程在互相切换的同时执行任务，充分利用 CPU 时间片，提高 CPU 的利用率。

  3. 并发处理：多线程可以实现并发处理，即同时处理多个任务。这在需要同时处理多个请求或者执行多个并行任务时非常有用，比如服务器处理多个客户端请求、下载文件时同时进行网络请求和数据处理等。

  4. 提高资源利用率：某些任务需要等待资源，比如网络请求、文件读写等操作，单线程下会导致等待时间增加。多线程可以在一个线程等待时，切换到其他线程执行任务，充分利用 CPU 和其他资源，减少等待时间。

  5. 提高系统的可响应性：当一个任务执行时间较长时，单线程会使得整个系统变得不可响应，因为该线程一直在执行任务，无法响应其他的操作。而多线程允许同时执行多个任务，可以保持系统的可响应性，及时响应用户的操作。

    6.带来良好的用户体验。

需要注意的是，多线程并不是适用于所有的情况，过多的线程可能导致资源竞争、死锁等问题。在设计和实现多线程程序时，需要仔细考虑线程同步、资源管理等问题，确保多线程程序的正确性和稳定性。

4.3 主线程

主线程是指程序启动时自动创建的线程，也称为主线程或者主程序线程。它是程序的入口点，负责执行程序的主要逻辑。在Java中，主线程是指main()方法所在线程。

主线程是程序的入口点，负责执行主要的程序逻辑，创建和管理其他线程，处理用户输入和显示界面等任务。它在程序的生命周期中起着重要的作用

二.自定义线程实现方式(有三种:Thread 、Runnable 、Callable< T >)

2.1 继承Thread类：

public NumShuffle  extends Thread {
    //重写run方法
    @Override
    public void run(){
        
    }
}

public static void main[String[] args]{
    NumShuffle numShuffle = new NumShuffle();
    //启动线程
    numShuffle.start();
}

优点 : 继承方式，优点明显，编程方式比较简单，直接就可以进行调用。

缺点 : 单继承，可扩展性低。

2.2 实现 Runnable 接口

​

public NumShuffle  implements Runnable{
    //重写run方法
    @Override
    public void run(){
        
    }
}

public static void main[String[] args]{
    NumShuffle numShuffle = new NumShuffle();
    Thread t1 = new Thread(numShuffle);
    //启动线程
   	t1.start();
}

优点 ：1.先将线程类进行实例化，在利用Thread实现线程的调用，稍显复杂。

​ 2.更高灵活度，可以实现继承的同时，还可以实现多接口。

​ 3.可以实现任务共享机制。

2.3 .实现 JUC 中的 Callable < T > 接口 （有返回值）

public class MyCallable implements java.util.concurrent.Callable<Integer> {
    @Override
    public Integer call() throws Exception {
     //循环输出100的值
        int sum = 0;

        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
    
    
    public static void main(String[] args) {
        // 创建一个实现Callable接口的对象
        MyCallable myCallable = new MyCallable();

        // 创建一个线程
        Thread thread = new Thread(myCallable);

        // 启动线程
        thread.start();

        // 等待线程执行完成并获取结果
        try {
            int result = thread.join();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
}

Callable接口相对于Runnable接口具有以下优点：

  1. 返回结果： Callable接口的call()方法可以返回一个结果，而Runnable接口的run()方法没有返回值。这使得在多线程任务中获取任务执行的结果变得更加方便。

  2. 抛出异常： Callable接口的call()方法可以抛出受检查的异常，而Runnable接口的run()方法不能抛出受检查的异常。这意味着在使用Callable时，可以更灵活地处理异常情况，而不需要在任务内部捕获所有异常。

  3. 可获得Future对象： 在使用ExecutorService调度任务时，submit()方法可以接受Callable对象，并返回一个Future对象。Future对象表示一个异步计算任务的未来结果。我们可以使用Future对象来获取任务的结果、取消任务的执行、查询任务是否完成等。

  4. 支持泛型： Callable接口支持泛型，可以指定任务返回结果的类型。这样可以在编译时进行类型检查，并避免在类型转换时出现错误。

综上所述，Callable接口在多线程编程中更加灵活和方便，特别适用于需要获取任务结果、处理异常或取消任务的场景。

2.4 、run方法调用和start调用的区别：

​ run方法是定义在线程类中，作为自定义线程，需要重写run方法，如果直接通过main主线程调用，就和调用普通的对象方法是一样的，并不会让线程单独启动。而start方法是定义在Thread类中的，通过Start方法，jvm虚拟机会自动调用run方法，执行线程任务，所以该种方式是能够实现多线程的方式。一个线程不能够重复执行。

三、线程调度：

在这里插入图片描述

3.1 setPriority()

作用 : 更改线程的优先级，优先级是从1~10设置，默认是5.

	Thread thread1 = new Thread(tr1,"线程优先级高");
	//设置线程的优先级
	thread1.setPriority(10);
	//打印优先级
	System.out.println(thread1.getPriority());
	//开始
	thread1.start();

3.2 sleep()

作用 : 能够让当前线程进入休眠状态， 通过毫秒的参数进行设定。

package com.csi;

import java.util.Date;

public class SleepTest extends Thread {

    @Override
    public void run()  {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "=" + i);
        }
    }

    public static void main(String[] args) {
        SleepTest st = new SleepTest() ;

        //调用
        st.start();

        SleepTest st1 = new SleepTest() ;

        //调用
        st1.start();

        SleepTest st2 = new SleepTest() ;

        //调用
        st2.start();

        SleepTest st3 = new SleepTest() ;

        //调用
        st3.start();

    }

}

3.3 join() （强制插入）

让一条线程强制插入到正在运行的线程过程中，在执行之后，再让出执行权。

public static void main(String[] args) {
    SleepTest st = new SleepTest() ;
    //调用
    st.start();

    for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName() + "=" + i);
        if(i == 5) {
            try {
                st.join(); //强势性，插入执行后，其他线程全部等待
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.4 yield() (礼让)

线程礼让，暂停当前正在执行的线程对象，让其他线程运行，但是不保证一定会礼让线程。

public static void main(String[] args) {
    SleepTest st = new SleepTest() ;
    //调用
    st.start();
    for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName() + "=" + i);
        if(i == 5) {
            Thread.yield();
        }
    }
}

3.5 interupt

可以通过调用线程的interrupt()方法来中断线程。interrupt()方法会设置线程的中断标志，表示线程被请求中断。


Thread thread = new Thread(() -> {
 
    while (!Thread.currentThread().isInterrupted()) {
        // 线程要执行的任务
 
        // 在任务中检查中断标志
        if (Thread.currentThread().isInterrupted()) {
            // 执行中断后的逻辑
            break;
        }
    }
});
thread.start(); // 启动线程
 
// 中断线程
thread.interrupt();

3.6 isAlive

可以使用isAlive()方法来判断一个线程是否存活。isAlive()方法返回一个布尔值，表示线程是否处于活动状态。


Thread thread = new Thread(() -> {
    // 线程要执行的任务
});
thread.start(); // 启动线程
 
// 判断线程是否存活
if (thread.isAlive()) {
    // 线程存活的处理逻辑
} else {
    // 线程不存活的处理逻辑
}

3.7 Tread.currentThread()

在Java中，Thread.currentThread()是一个静态方法，用于获取当前正在执行的线程对象。它的调度作用可以有以下几个方面：

  1. 获取线程对象： Thread.currentThread()可以返回当前执行代码的线程对象，这对于需要操作当前线程的一些场景非常有用。例如，可以使用它来获取线程的名称、优先级、状态等信息，或对当前线程进行操作，如暂停、恢复或中断。

  2. 线程同步： 在多线程环境下，我们经常需要对共享资源进行同步访问，以避免竞态条件和数据不一致的问题。通过Thread.currentThread()可以获取当前执行代码的线程对象，从而可以在同步块或同步方法中使用当前线程对象作为锁对象，实现线程间的同步。

  3. 线程局部变量： 线程局部变量是指每个线程都有自己独立的变量副本，相互之间不会产生冲突。通过Thread.currentThread()可以获取当前线程对象，从而可以使用线程对象的ThreadLocal实例，来管理线程局部变量。

总的来说，Thread.currentThread()的调度作用是为了方便获取当前执行代码的线程对象，并通过它进行线程控制、线程同步和线程局部变量的管理。

四、线程同步

public class SellTicket implements Runnable {

    //车站内准备卖100张车票
    private int ticket = 10;

    /*
     * 主任务卖票
     * */
    @Override
    public void run() {
        sellTicket();
    }

    public void sellTicket() {
        while(true) {
            if(ticket > 0) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                ///同步代码块
                System.out.println(Thread.currentThread().getName() + "车票被卖出去了" + ticket-- + "张票!");
            }else{
                System.out.println("票卖完了。。。");
                break;
            }
       }
}

在这里插入图片描述

当多个线程共享同一资源时，可能会造成线程安全问题，因此，java提供了一个关键字synchronized。该关键字能够修饰方法，被称为同步方法，如果对某一段代码进行修饰和包围，代表是一个同步代码块。由于采用同步机制，所有线程会造成排队的情况，导致程序性能下降。因此只能是再一些带有“伤害性”的代码中使用。

4.1 、同步方法

public synchronized 返回值 方法名(参数){
    
}

public synchronized void sellTicket() {
    while(true) {
        if(ticket > 0) {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            ///同步代码块
            System.out.println(Thread.currentThread().getName() + "车票被卖出去了" + ticket-- + "张票!");

        }else{
            System.out.println("票卖完了。。。");
            break;
        }
        System.out.println("hello,world");
    }
}

4.2、同步代码块

​

public void show(){
    synchronized(锁对象){
        
    }
}

​ 1.通过锁对象可以将当前的代码段进行锁定，其他的线程需要排队。

​ 2.作为同步方法一旦被整体修饰，就代表着整个方法内部都不能够实现异步访问。

​ 3.作为同步代码块，可以先调用synchronized修饰之前的代码，提升程序的执行性能。

public void sellTicket() {
    System.out.println("执行方法1.。。。");
    while(true) {
    	synchronized (this) {
            if(ticket > 0) {
            try {
            	Thread.sleep(300);
            } catch (InterruptedException e) {
            	throw new RuntimeException(e);
            }

    ///同步代码块
    System.out.println(Thread.currentThread().getName() + "车票被卖出去了" + ticket-- + "张票!");

            }else{
                System.out.println("票卖完了。。。");
                break;
            }
      }
    System.out.println("hello,world");
    }
}

4.3、静态同步代码块

public static synchronized 方法名(){
    
}
public static void show(){
    synchronized(当前类名的.class){
        
    }
}

​ 1.当在一个静态的方法上添加synchronized关键字，会采用当前类的.class类信息作为锁对象。

​ 2.如果是一个静态代码块，可使用静态的变量进行修饰，但是有可能会发生在外部修改锁对象的值。建议采用类的.class作为锁对象。

​ 3.线程互斥：线程带有锁后，可能会出现互斥现象。静态的同步方法或方法块，不会出现互斥的现象。

public static void sellTicket() {
    System.out.println("执行方法1.。。。");
    while(true) {
    	synchronized (sellTicket.class) {
            if(ticket > 0) {
            try {
            	Thread.sleep(300);
            } catch (InterruptedException e) {
            	throw new RuntimeException(e);
            }

    ///同步代码块
    System.out.println(Thread.currentThread().getName() + "车票被卖出去了" + ticket-- + "张票!");

            }else{
                System.out.println("票卖完了。。。");
                break;
            }
      }
    System.out.println("hello,world");
    }
}

五、Lock锁

​ 通过synchronized都是java中的锁定义。由于synchronized灵活度较低，没有办法实现锁的监控过程（lock、unlock）以及公平锁的实现，所以在JDK5的版本中，在java.util.concrrent.locks包中添加Lock接口，同时给了一些实现类。

​

​ 比较常用的实现类 ------> ReentrantLock类。

package com.csi;

import java.util.Vector;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTicket implements Runnable {

    //车站内准备卖100张车票
    private int ticket = 10;

    //增加了Lock锁实现
    private Lock lock = new ReentrantLock(true);
    /*
     * 主任务卖票
     * */
    @Override
    public void run() {
        sellTicket();
    }

    public void sellTicket() {

        while(true) {
            lock.lock();  //上锁
            if(ticket > 0) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                ///同步代码块
                System.out.println(Thread.currentThread().getName() + "车票被卖出去了" + ticket-- + "张票!");

                lock.unlock();  //释放锁
            }else{
                System.out.println("票卖完了。。。");

                lock.unlock();  //释放锁
                break;
            }
       }


    }

5.1synchronized与lock的区别

​ synchronized是java内置的一个线程同步关键字， 而Lock是J.U.C包下面的一个接口，他有很多实现类，比如ReentrantLock就是它的一个实现类。

​

​ synchronized可以写在需要同步的对象、方法或者是特定的代码块中。

​ lock控制锁的粒度是通过lock()和unlock()方法来实现的，以ReentrantLock为列

Lock lock = new ReentrantLock();
public void sync(){
    lock.lock(); //添加锁
    //TODO线程安全的代码
    lock.unlock(); //释放锁
}

​ 这种方式，是可以保证lock()方法和unlock()方法之间的代码是线程安全的。而锁的作用域，取决于Lock实列的生命周期。

​ Lock比synchronized在使用上相对来说要更加灵活一些。Lock可以自主地去决定什么时候加锁，什么时候释放锁。只需要调用lock()和unlock()这两个方法就可以了。需要注意的是，为了避免死锁，一般我们unlock()方法写在finally块中。

​ 另外，lock还提供了非阻塞的竞争锁的方法叫trylock()，这个方法可以通过返回true或者fasle来告诉当前线程是否已经有其他线程正在使用锁。

​ 而synchronized是关键字，无法去扩展实现非阻塞竞争锁的方法。另外，synchronized只有代码块执行结束或者代码出现异常的时候才会释放锁，因此，它对锁的释放是被动的。

​

​ synchronized和Lock在性能上差别不大。在实现上有一些区别：

​ 1. synchronized 采用的是悲观锁机制，synchronized 是托管给JVM 执行的。在JDK1.6以后采用了偏向锁、轻量级锁、重量级锁及升级的方式进行优化。

​ 2. 而 Lock 用的是乐观锁机制。控制锁的代码由用于自定义，也采用CAS自旋锁进行了优化。

​ 3. 二者在一般情况下没有什么区别，但是在非常复杂的同步应用中，建议使用Lock。

​ 4. 因为synchronized只提供了非公平锁的实现，而Lock提供了公平锁和非公平锁的机制。

​ 5. 公平锁是指线程竞争锁资源的时候，如果已经有其他线程正在排队或者等待锁释放，那么当前竞争锁的线程是无法去插队的。

​ 6. 而非公平锁就是不管是否线程再排队等待锁，它都会去尝试竞争一次锁。

在这里插入图片描述

线程高级部分

一、线程状态：

1.1线程状态的概述

​ 线程由生到死的完整过程：

​ 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周

​ 期中，有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

​ 这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析

在这里插入图片描述

1.2wait() 等待和notify() 唤醒

​ Object类的方法:

​ public void wait() :让当前线程进入到等待状态 此方法必须锁对象调用

public class Demo1_wait {
	public static void main(String[] args) throws InterruptedException {
		// 步骤1 : 子线程开启,进入无限等待状态, 没有被唤醒,无法继续运行.
		new Thread(() -> {
            try {
                
            System.out.println("begin wait ....");
            synchronized ("") {
            	"".wait();
            }
			System.out.println("over");
		} catch (Exception e) {
		}
	}).start();
}

public void notify() : 唤醒当前锁对象上等待状态的线程 此方法必须锁对象调用

public class Demo2_notify {
	public static void main(String[] args) throws InterruptedException {
		// 步骤1 : 子线程开启,进入无限等待状态, 没有被唤醒,无法继续运行.
		new Thread(() -> {
			try {
					System.out.println("begin wait ....");
				synchronized ("") {
                    "".wait();
                    }
					System.out.println("over");
                } catch (Exception e) {
                	}
			}).start();
		//步骤2: 加入如下代码后, 3秒后,会执行notify方法, 唤醒wait中线程.
        Thread.sleep(3000);
        new Thread(() -> {
			try {
				synchronized ("") {
					System.out.println("唤醒");
                    "".notify();
                    }
                } catch (Exception e) {
                }
    		}).start();
    	}
}

1.4wait和notify案例

定义一个集合，包子铺线程完成生产包子，包子添加到集合中；吃货线程完成购买包子，包子从集合中移除。

  1. 当包子没有时（包子状态为false），吃货线程等待.

  2. 包子铺线程生产包子（即包子状态为true），并通知吃货线程（解除吃货的等待状态）

代码示例：

生成包子类：

public class BaoZiPu extends Thread {
    private List<String> list;

    public BaoZiPu(String name, ArrayList<String> list) {
        super(name);
        this.list = list;
    }

    @Override
    public void run() {
        int i = 0;
        while (true) {
            //list作为锁对象
            synchronized (list) {
                if (list.size() > 0) {
                    //存元素的线程进入到等待状态
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果线程没进入到等待状态 说明集合中没有元素
                //向集合中添加元素
                list.add("包子" + i++);
                System.out.println(list);
                //集合中已经有元素了 唤醒获取元素的线程
                list.notify();
            	}
        	}
    	}
	}
}

消费包子类：

import java.util.ArrayList;
import java.util.List;

public class ChiHuo extends Thread {
    private List<String> list;

    public ChiHuo(String name, ArrayList<String> list) {
        super(name);
        this.list = list;
    }

    @Override
    public void run() {
		//为了能看到效果 写个死循环
        while (true) {
			//由于使用的同一个集合 list作为锁对象
            synchronized (list) {
				//如果集合中没有元素 获取元素的线程进入到等待状态
                if (list.size() == 0) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
				//如果集合中有元素 则获取元素的线程获取元素(删除)
                list.remove(0);
				//打印集合 集合中没有元素了
                System.out.println(list);
				//集合中已经没有元素 则唤醒添加元素的线程 向集合中添加元素
                list.notify();
           	 }
     	  }
  	  }
	}
}

测试类：

public class Demo {
    public static void main(String[] args) {
		//等待唤醒案例
        List<String> list = new ArrayList<>();
		// 创建线程对象
        BaoZiPu bzp = new BaoZiPu("包子铺", list);
        ChiHuo ch = new ChiHuo("吃货", list);
		// 开启线程
        bzp.start();
        ch.start();
    }
}

二、volatile关键字

2.1 、看程序说结果

​

public class VolatileThread extends Thread {
    // 定义成员变量
    private boolean flag = false ;
    public boolean isFlag() { return flag;}
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 将flag的值更改为true
        this.flag = true ;
        System.out.println("flag=" + flag);
    }
}
public class VolatileThreadDemo {// 测试类
    public static void main(String[] args) {
        // 创建VolatileThread线程对象
        VolatileThread volatileThread = new VolatileThread() ;
        volatileThread.start();
        // main方法
        while(true) {
            if(volatileThread.isFlag()) {
                System.out.println("执行了======");
            }
        }
    }
}

通过观察控制台，我们看到，VolatileThread线程中已经将flag设置为true，但main()方法中始终没有读到，从而没有打印。

2.2 、JMM

概述：JMM(Java Memory Model)Java内存模型,是java虚拟机规范中所定义的一种内存模型。

​ Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。

​ 所有的共享变量都存储于主内存。这里所说的变量指的是实例变量和类变量。不包含局部变量，因为局部变

​ 量是线程私有的，因此不存在竞争问题。每一个线程还存在自己的工作内存，线程

​ 的工作内存，保留了被线程使用的变量的工作副本。线程对变量的所有的操作(读，取)都必须在工作内存中

​ 完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问

​ 对方工作内存中的变量，线程间变量的值的传递需要通过主内存完成。

在这里插入图片描述

2.3问题分析:

在这里插入图片描述

  1. VolatileThread线程从主内存读取到数据放入其对应的工作内存

  2. 将flag的值更改为true，但是这个时候flag的值还没有写回主内存

  3. 此时main方法读取到了flag的值为false

  4. 当VolatileThread线程将flag的值写回去后，但是main函数里面的while(true)调用的是系统比较底层的

    代码，速度快，快到没有时间再去读取主存中的值，

    所以while(true)读取到的值一直是false。(如果有一个时刻main线程从主内存中读取到了主内存中flag的最新值，那么if语句就可以执行，main线程何时从主内存中读取最新的值，我们无法控制)

2.4. 问题处理

2.4.1加锁
// main方法
while(true) {
	synchronized (volatileThread) {
		if(volatileThread.isFlag()) {
			System.out.println("执行了");
		}
	}
}

某一个线程进入synchronized代码块前后，执行过程入如下：

a.线程获得锁

b.清空工作内存

c.从主内存拷贝共享变量最新的值到工作内存成为副本

d.执行代码

e.将修改后的副本的值刷新回主内存中

f.线程释放锁

2.4.2 volatile关键字

使用volatile关键字：

private volatile boolean flag ;

工作原理：

在这里插入图片描述

  1. VolatileThread线程从主内存读取到数据放入其对应的工作内存

  2. 将flag的值更改为true，但是这个时候flag的值还没有写会主内存

  3. 此时main方法main方法读取到了flag的值为false

  4. 当VolatileThread线程将flag的值写回去后，失效其他线程对此变量副本

  5. 再次对flag进行操作的时候线程会从主内存读取最新的值，放入到工作内存中

    总结： volatile保证不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，

当修改写回主内存时，另外一个线程立即看到最新的值。

​ 但是volatile不保证原子性。

2.4.3 volatile与synchronized

  • volatile只能修饰实例变量和类变量，而synchronized可以修饰方法，以及代码块。

  • volatile保证数据的可见性，但是不保证原子性(多线程进行写操作，不保证线程安全);而synchronized

是一种排他（互斥）的机制。

三 、原子性

概述：所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何

​ 因素的干扰而中断，要么所有的操作都不执行。

3.1. 看程序说结果

public class VolatileAtomicThread implements Runnable {
    // 定义一个int类型的遍历
    private int count = 0 ;
    @Override
    public void run() {
        // 对该变量进行++操作，100次
        for(int x = 0 ; x < 100 ; x++) {
            count++ ;
            System.out.println("count =========>>>> " + count);
        }
    }
}
public class VolatileAtomicThreadDemo {
    public static void main(String[] args) {
        // 创建VolatileAtomicThread对象
        VolatileAtomicThread volatileAtomicThread = new VolatileAtomicThread() ;
        // 开启100个线程对count进行++操作
        for(int x = 0 ; x < 100 ; x++) {
            new Thread(volatileAtomicThread).start();
        }
    }
}

执行结果：不保证一定是10000

3.2 、问题原理说明

以上问题主要是发生在count++操作上：

count++操作包含3个步骤：

  • 从主内存中读取数据到工作内存

  • 对工作内存中的数据进行++操作

  • 将工作内存中的数据写回到主内存

count++操作不是一个原子性操作，也就是说在某一个时刻对某一个操作的执行，有可能被其他的线程打

断。

在这里插入图片描述

1）假设此时x的值是100，线程A需要对改变量进行自增1的操作，首先它需要从主内存中读取变量x的值。由

于CPU的切换关系，此时CPU的执行权被切换到了B线程。A线程就处于就绪状态，B线程处于运行状态

2）线程B也需要从主内存中读取x变量的值,由于线程A没有对x值做任何修改因此此时B读取到的数据还是100

3）线程B工作内存中x执行了+1操作，但是未刷新之主内存中

4）此时CPU的执行权切换到了A线程上，由于此时线程B没有将工作内存中的数据刷新到主内存，因此A线程

工作内存中的变量值还是100，没有失效。A线程对工作内存中的数据进行了+1操作

5）线程B将101写入到主内存

6）线程A将101写入到主内存

虽然计算了2次，但是只对A进行了1次修改。

3.3. volatile原子性测试

代码测试

// 定义一个int类型的变量
private volatile int count = 0 ;

小结：在多线程环境下，volatile关键字可以保证共享数据的可见性，但是并不能保证对数据操作的原子性

（在多线程环境下volatile修饰的变量也是线程不安全的）。

在多线程环境下，要保证数据的安全性，我们还需要使用锁机制。

volatile的使用场景

  • 开关控制

    利用可见性特点，控制某一段代码执行或者关闭(比如今天课程的第一个案例)。

  • 多个线程操作共享变量，但是是有一个线程对其进行写操作，其他的线程都是读

3.4. 问题解决

使用锁机制

我们可以给count++操作添加锁，那么count++操作就是临界区的代码，临界区只能有一个线程去执行，所

以count++就变成了原子操作。

public class VolatileAtomicThread implements Runnable {
    // 定义一个int类型的变量
    private volatile int count = 0 ;
    private static final Object obj = new Object();
    @Override
    public void run() {
    // 对该变量进行++操作，100次
        for(int x = 0 ; x < 100 ; x++) {
            synchronized (obj) {
                count++ ;
                System.out.println("count =========>>>> " + count);
            }
        }
    }
}
原子类

概述：java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供

了一种用法简单，性能高效，线程安全地更新一个变量的方式。

AtomicInteger

原子型Integer，可以实现原子更新操作

在这里插入图片描述

案例改造（使用AtomicInteger对案例进行改造.）

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileAtomicThread implements Runnable {
    // 定义一个int类型的变量
    private AtomicInteger atomicInteger = new AtomicInteger() ;
    @Override
    public void run() {
        // 对该变量进行++操作，100次
        for(int x = 0 ; x < 100 ; x++) {
            int i = atomicInteger.getAndIncrement();
            System.out.println("count =========>>>> " + i);
        }
    }
}

3.5、原子类CAS机制实现线程安全

概述：

CAS的全称是： Compare And Swap(比较再交换); 是现代CPU广泛支持的一种对内存中的共享数据进行操作

的一种特殊指令。CAS可以将read-modify-check-write

转换为原子操作，这个原子操作直接由处理器保证。

CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

3.6、CAS与Synchronized：乐观锁，悲观锁。

CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别？

Synchronized是从悲观的角度出发（悲观锁）

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别

人想拿这个数据就会阻塞直到它拿到锁

（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。因此Synchronized

我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。性能较差！！

CAS是从乐观的角度出发:

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断

一下在此期间别人有没有去更新这个数据。

CAS这种机制我们也可以将其称之为乐观锁。综合性能较好！

四 、并发包

​ 在JDK的并发包里提供了几个非常有用的并发容器和并发工具类。供我们在多线程开发中进行使用。

4.1 ConcurrentHashMap

为什么要使用ConcurrentHashMap：

  1. HashMap线程不安全，会导致数据错乱

  2. 使用线程安全的Hashtable效率低下

基于以上两个原因，便有了ConcurrentHashMap的登场机会。

  • HashMap线程不安全演示。

公有、静态的集合：

public class Const {
	public static HashMap<String,String> map = new HashMap<>();
}

线程，向map中写入数据：

public void run() {
	for (int i = 0; i < 500000; i++) {
		Const.map.put(this.getName() + (i + 1), this.getName() + i + 1);
	}
	System.out.println(this.getName() + " 结束！");
}

测试类：

public class Demo {
	public static void main(String[] args) throws InterruptedException {
        Thread1A a1 = new Thread1A();
        Thread1A a2 = new Thread1A();
        a1.setName("线程1-");
        a2.setName("线程2-");
        
        a1.start();
        a2.start();
        //休息10秒，确保两个线程执行完毕
        Thread.sleep(1000 * 5);
        //打印集合大小
        System.out.println("Map大小：" + Const.map.size());
     }
}

说明：两个线程分别向同一个map中写入50000个键值对，最后map的size应为：100000，但多运行几次会

发现有以下几种错误：

  1. 假死：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HjgU5f02-1689680016369)(C:\Users\恒总的雷神911mt\AppData\Roaming\Typora\typora-user-images\image-20230717225055752.png)]

  1. 异常：
    在这里插入图片描述

  2. 错误结果：

在这里插入图片描述

  • 为了保证线程安全，可以使用Hashtable。注意：线程中加入了计时

公有、静态的集合：

public class Const {
	public static Hashtable<String,String> map = new Hashtable<>();
}

线程，向map中写入数据：

public void run() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 500000; i++) {
			Const.map.put(this.getName() + (i + 1), this.getName() + i + 1);
		}
            long end = System.currentTimeMillis();
            System.out.println(this.getName() + " 结束！用时：" + (end - start) + " 毫
            秒");
	}

测试类：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Thread1A a1 = new Thread1A();
        Thread1A a2 = new Thread1A();
        a1.setName("线程1-");
        a2.setName("线程2-");
        a1.start();
        a2.start();
		//休息10秒，确保两个线程执行完毕
        Thread.sleep(1000 * 5);
		//打印集合大小
        System.out.println("Map大小：" + Const.map.size());
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z9DlYMPN-1689680016370)(C:\Users\恒总的雷神911mt\AppData\Roaming\Typora\typora-user-images\image-20230717225327000.png)]

​ ConcurrentHashMap仍能保证结果正确，而且提高了效率。

HashTable效率低下原因：

public synchronized V put(K key, V value)
public synchronized V get(Object key)

HashTable容器使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低

下。因为当一个线程访问HashTable的同步方法，其他线程也访问HashTable的同步方法时，会进入阻塞状

态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元

素，所以竞争越激烈效率越低。

在这里插入图片描述

ConcurrentHashMap高效的原因：CAS +局部(synchronized)锁定分段式锁

在这里插入图片描述

4.2 CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作，再执行自己。

例如：线程1要执行打印：A和C，线程2要执行打印：B，但线程1在打印A后，要线程2打印B之后才能打印

C，所以：线程1在打印A后，必须等待线程2打印完B之后才能继续执行。

CountDownLatch构造方法：

public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象

CountDownLatch重要方法:

public void await() throws InterruptedException// 让当前线程等待
public void countDown() // 计数器进行减1
  • 示例

1). 制作线程1：

public class ThreadA extends Thread {
        private CountDownLatch down ;
        public ThreadA(CountDownLatch down) {
            this.down = down;
        }
        @Override
        public void run() {
            System.out.println("A");
            try {
                down.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("C");
        }
}

2). 制作线程2：

public class ThreadB extends Thread {
        private CountDownLatch down ;
        public ThreadB(CountDownLatch down) {
            this.down = down;
        }
        @Override
        public void run() {
            System.out.println("B");
            down.countDown();
        }
    }

3).制作测试类：

 public class Demo {
        public static void main(String[] args) {
            CountDownLatch down = new CountDownLatch(1);//创建1个计数器
            new ThreadA(down).start();
            new ThreadB(down).start();
    }
}

4). 执行结果：

会保证按：A B C的顺序打印。说明：

CountDownLatch中count down是倒数的意思，latch则是门闩的含义。整体含义可以理解为倒数的门栓，

似乎有一点“三二一，芝麻开门”的感觉。

CountDownLatch是通过一个计数器来实现的，每当一个线程完成了自己的任务后，可以调用countDown()

方法让计数器-1，当计数器到达0时，调用CountDownLatch。

await()方法的线程阻塞状态解除，继续执行。

4.3 CyclicBarrier

概述

CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一

个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线

程才会继续运行。

例如：公司召集5名员工开会，等5名员工都到了，会议开始。

我们创建5个员工线程，1个开会线程，几乎同时启动，使用CyclicBarrier保证5名员工线程全部执行后，再

执行开会线程。

CyclicBarrier构造方法：

public CyclicBarrier(int parties, Runnable barrierAction)
// 用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景

CyclicBarrier重要方法：

public int await()
// 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞

  • 示例代码：

    1). 制作员工线程：

 public class PersonThread extends Thread {
        private CyclicBarrier cbRef;
        public PersonThread(CyclicBarrier cbRef) {
            this.cbRef = cbRef;
        }
        @Override
        public void run() {
            try {
                Thread.sleep((int) (Math.random() * 1000));
                System.out.println(Thread.currentThread().getName() + " 到了! ");
                cbRef.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
}

2). 制作开会线程：

public class MeetingThread extends Thread {
        @Override
        public void run() {
            System.out.println("好了，人都到了，开始开会......");
        }
    }

3). 制作测试类：

public class Demo {
        public static void main(String[] args) {
            CyclicBarrier cbRef = new CyclicBarrier(5, new MeetingThread());
            //等待5个线程执行完毕，再执行MeetingThread
            PersonThread p1 = new PersonThread(cbRef);
            PersonThread p2 = new PersonThread(cbRef);
            PersonThread p3 = new PersonThread(cbRef);
            PersonThread p4 = new PersonThread(cbRef);
            PersonThread p5 = new PersonThread(cbRef);
            p1.start();
            p2.start();
            p3.start();
            p4.start();
            p5.start();
        }
    }
使用场景

使用场景：CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。

需求：使用两个线程读取2个文件中的数据，当两个文件中的数据都读取完毕以后，进行数据的汇总操作。

4.4 Semaphore

Semaphore（发信号）的主要作用是控制线程的并发数量。

synchronized可以起到"锁"的作用，但某个时间段内，只能有一个线程允许执行。

Semaphore可以设置同时允许几个线程执行。

Semaphore字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目。

Semaphore构造方法：

public Semaphore(int permits)					permits 表示许可线程的数量
public Semaphore(int permits, boolean fair)		fair 表示公平性，如果这个设为 true的话，下次执行的线程会是等待最久的线程

Semaphore重要方法：

public void acquire() throws InterruptedException 		 表示获取许可
public void release()									 release() 表示释放许可
  • 示例一：同时允许1个线程执行

1). 制作一个Service类：

public class Service {
        private Semaphore semaphore = new Semaphore(1);//1表示许可的意思，表示最多允许1个线程
        执行acquire()和release()之间的内容
        public void testMethod() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()
                        + " 进入 时间=" + System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()
                        + " 结束 时间=" + System.currentTimeMillis());
                semaphore.release();
            //acquire()和release()方法之间的代码为"同步代码"
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

2). 制作线程类：

   public class ThreadA extends Thread {
        private Service service;
        public ThreadA(Service service) {
            super();
            this.service = service;
        }
        @Override
        public void run() {
            service.testMethod();
        }
    }

3). 测试类：

public class Demo {
        public static void main(String[] args) {
            Service service = new Service();
            //启动5个线程
            for (int i = 1; i <= 5; i++) {
                ThreadA a = new ThreadA(service);
                a.setName("线程 " + i);
                a.start();//5个线程会同时执行Service的testMethod方法，而某个时间段只能有1个线程执
                行
            }
        }
    }

4). 结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mMckJ4q8-1689680016371)(C:\Users\恒总的雷神911mt\AppData\Roaming\Typora\typora-user-images\image-20230718191730410.png)]

  • 示例二：同时允许2个线程同时执行

    1). 修改Service类，将new Semaphore(1)改为2即可：

public class Service {
        private Semaphore semaphore = new Semaphore(2);//2表示许可的意思，表示最多允许2个线程
        执行acquire()和release()之间的内容
        public void testMethod() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()
                        + " 进入 时间=" + System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName()
                        + " 结束 时间=" + System.currentTimeMillis());
                semaphore.release();
                //acquire()和release()方法之间的代码为"同步代码"
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

​ 2). 再次执行结果：

在这里插入图片描述

4.5 Exchanger

概述

Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。

这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程

也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据

传递给对方。

Exchanger构造方法：

public Exchanger()

Exchanger重要方法：

public V exchange(V x)
  • 示例一：exchange方法的阻塞特性

1).制作线程A，并能够接收一个Exchanger对象：

 public class ThreadA extends Thread {
        private Exchanger<String> exchanger;
        public ThreadA(Exchanger<String> exchanger) {
            super();
            this.exchanger = exchanger;
        }
        @Override
        public void run() {
            try {
                System.out.println("线程A欲传递值'礼物A'给线程B，并等待线程B的值...");
                System.out.println("在线程A中得到线程B的值=" + exchanger.exchange("礼物A"));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

2). 制作main()方法：

public class Demo {
        public static void main(String[] args) {
            Exchanger<String> exchanger = new Exchanger<String>();
            ThreadA a = new ThreadA(exchanger);
            a.start();
        }
    }

3).执行结果：

在这里插入图片描述

  • 示例二：exchange方法执行交换

1).制作线程A：

public class ThreadA extends Thread {
        private Exchanger<String> exchanger;
        public ThreadA(Exchanger<String> exchanger) {
            super();
            this.exchanger = exchanger;
        }
        @Override
        public void run() {
            try {
                System.out.println("线程A欲传递值'礼物A'给线程B，并等待线程B的值...");
                System.out.println("在线程A中得到线程B的值=" + exchanger.exchange("礼物A"));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

2).制作线程B：

public class ThreadB extends Thread {
        private Exchanger<String> exchanger;
        public ThreadB(Exchanger<String> exchanger) {
            super();
            this.exchanger = exchanger;
        }
        @Override
        public void run() {
            try {
                System.out.println("线程B欲传递值'礼物B'给线程A，并等待线程A的值...");
                System.out.println("在线程B中得到线程A的值=" + exchanger.exchange("礼物B"));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

3).制作测试类：

 public class Demo {
        public static void main(String[] args) throws InterruptedException {
            Exchanger<String> exchanger = new Exchanger<String>();
            ThreadA a = new ThreadA(exchanger);
            ThreadB b = new ThreadB(exchanger);
            a.start();
            b.start();
        }
    }

4).执行结果：

在这里插入图片描述

  • 示例三：exchange方法的超时

1).制作线程A：

public class ThreadA extends Thread {
        private Exchanger<String> exchanger;
        public ThreadA(Exchanger<String> exchanger) {
            super();
            this.exchanger = exchanger;
        }
        @Override
        public void run() {
            try {
                System.out.println("线程A欲传递值'礼物A'给线程B，并等待线程B的值，只等5秒...");
                System.out.println("在线程A中得到线程B的值 =" + exchanger.exchange("礼物
                        A",5, TimeUnit.SECONDS));
                        System.out.println("线程A结束！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                System.out.println("5秒钟没等到线程B的值，线程A结束！");
            }
        }
    }

2).制作测试类：

 public class Run {
        public static void main(String[] args) {
            Exchanger<String> exchanger = new Exchanger<String>();
            ThreadA a = new ThreadA(exchanger);
            a.start();
        }
    }

3).测试结果：

在这里插入图片描述

使用场景

使用场景：可以做数据校对工作

需求：比如我们需要将纸制银行流水通过人工的方式录入成电子银行流水。为了避免错误，采用AB岗两人进

行录入，录入到两个文件中，系统需要加载这两个文件，

并对两个文件数据进行校对，看看是否录入一致，

五 、线程池方式

5.1线程池

**线程池：**线程池是一种线程管理的机制，它可以预先创建一组线程，在需要执行任务时，从线程池中获取线程来执行任务，而不是每次都创建新线程。这种方式可以避免频繁创建和销毁线程的开销，提高线程的复用性和执行效率。

好处：

  • 降低线程创建和销毁的开销：线程的创建和销毁是有开销的，包括内存分配、资源绑定等操作。通过使用线程池，可以重用已创建的线程，避免频繁创建和销毁线程的开销，提高系统的性能和效率。

  • 提高线程的复用性：线程池可以将线程进行管理和复用，当一个任务执行完毕后，线程可以立即被分配到下一个任务上，不需要等待线程的创建和销毁，从而减少线程的等待时间，提高线程的复用性。

  • 控制并发线程数量：线程池可以限制同时执行的任务数，通过设置线程池的线程数目，可以防止系统资源过度占用和线程数量过多导致的性能下降。这样可以合理分配系统资源，提高系统整体的稳定性和可伸缩性。

  • 提供更多的任务调度和管理功能：线程池提供了丰富的任务调度和管理功能，如定时执行任务、延迟执行任务、取消任务等。同时，线程池还可以监控任务的执行情况，获取任务执行的结果（通过Future对象），便于后续的处理。

  • 提供线程执行的统一管理：通过线程池，可以将线程的执行和资源的管理集中在一个地方，方便统一管理和监控线程的状态、异常等。同时，线程池提供了优雅地关闭线程池的方法，保证线程的正常停止和资源的释放。

5.2 线程池的使用步骤

  1. 创建线程池对象。
  2. 创建Runnable接口子类对象。(task)
  3. 提交Runnable接口子类对象。(take task)
  4. 关闭线程池(一般不做)。

例子：

需求 使用线程池方式执行任务,返回1-n的和

分析 因为需要返回求和结果 , 所以使用 Callable 方式的任务


public class SumCallable implements Callable<Integer> {
 
    private int num;
 
    public SumCallable(int num){
        this.num = num;
    }
    @Override
    public Integer call() throws Exception {
        // 接收总值
        int sum = 0;
 
        // 计算从1 - num 的总和
        for (int i = 1; i <= num; i++) {
            sum += i;
        }
        return sum;
    }
}

public class TestCallable {
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建线程缓冲池
        ExecutorService executorService = Executors.newFixedThreadPool(2);
 
        // 创建任务
        SumCallable sc = new SumCallable(100);
 
        // 提交任务到线程池并返回Future对象
        Future<Integer> submit = executorService.submit(sc);
 
        // 打印输入1 - num 的总和
        System.out.println("总和为:" + submit.get());
 
        //关闭线程池
        executorService.shutdown();
 
    }
 
}

六 、 死锁

6.1 概念

死锁指的是在并发编程中，两个或多个线程互相持有对方需要的资源，并且无法继续执行下去的一种状态。在死锁状态下，所有的线程都被阻塞，无法继续执行，只能等待其他线程释放所持有的资源。

6.2 产生条件

互斥条件（Mutual Exclusion）：至少有一个资源是独占的，即一次只能被一个线程持有。
请求与保持条件（Hold and Wait）：线程至少持有一个资源，并且在等待其他线程释放资源时不释放自己持有的资源。
不可剥夺条件（No Preemption）：线程所获得的资源不能被强制性地抢占，只能自愿释放。
循环等待条件（Circular Wait）：线程之间存在一个循环等待资源的关系，形成一个闭环。

6.3 死锁代码


public class Demo05 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        new Thread(mr).start();
        new Thread(mr).start();
    }
}
 
class MyRunnable implements Runnable {
    Object objA = new Object();
    Object objB = new Object();
 
    /*
    嵌套1 objA
    嵌套1 objB
    嵌套2 objB
    嵌套1 objA
    */
    @Override
    public void run() {
        synchronized (objA) {
            System.out.println("嵌套1 objA");
            synchronized (objB) {// t2, objA, 拿不到B锁,等待
            System.out.println("嵌套1 objB");
            }
        }
 
    synchronized (objB) {
        System.out.println("嵌套2 objB");
        synchronized (objA) {// t1 , objB, 拿不到A锁,等待
            System.out.println("嵌套2 objA");
        }
    }
  
}

0;

    // 计算从1 - num 的总和
    for (int i = 1; i <= num; i++) {
        sum += i;
    }
    return sum;
}

}




```java
public class TestCallable {
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建线程缓冲池
        ExecutorService executorService = Executors.newFixedThreadPool(2);
 
        // 创建任务
        SumCallable sc = new SumCallable(100);
 
        // 提交任务到线程池并返回Future对象
        Future<Integer> submit = executorService.submit(sc);
 
        // 打印输入1 - num 的总和
        System.out.println("总和为:" + submit.get());
 
        //关闭线程池
        executorService.shutdown();
 
    }
 
}

六 、 死锁

6.1 概念

死锁指的是在并发编程中，两个或多个线程互相持有对方需要的资源，并且无法继续执行下去的一种状态。在死锁状态下，所有的线程都被阻塞，无法继续执行，只能等待其他线程释放所持有的资源。

6.2 产生条件

互斥条件（Mutual Exclusion）：至少有一个资源是独占的，即一次只能被一个线程持有。
请求与保持条件（Hold and Wait）：线程至少持有一个资源，并且在等待其他线程释放资源时不释放自己持有的资源。
不可剥夺条件（No Preemption）：线程所获得的资源不能被强制性地抢占，只能自愿释放。
循环等待条件（Circular Wait）：线程之间存在一个循环等待资源的关系，形成一个闭环。

6.3 死锁代码


public class Demo05 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        new Thread(mr).start();
        new Thread(mr).start();
    }
}
 
class MyRunnable implements Runnable {
    Object objA = new Object();
    Object objB = new Object();
 
    /*
    嵌套1 objA
    嵌套1 objB
    嵌套2 objB
    嵌套1 objA
    */
    @Override
    public void run() {
        synchronized (objA) {
            System.out.println("嵌套1 objA");
            synchronized (objB) {// t2, objA, 拿不到B锁,等待
            System.out.println("嵌套1 objB");
            }
        }
 
    synchronized (objB) {
        System.out.println("嵌套2 objB");
        synchronized (objA) {// t1 , objB, 拿不到A锁,等待
            System.out.println("嵌套2 objA");
        }
    }
  
}
帅气哼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
多线程学习笔记
qq_41293397的博客
02-03 361
Vector和CopyOnWriteArrayList都是线程安全的List，底层都是数组实现的，Vector的每个方法都进行了加锁，而CopyOnWriteArrayList的读操作是不加锁的，因此CopyOnWriteArrayList的读性能远高于Vector，Vector每次扩容的大小都是原来数组大小的2倍，而CopyOnWriteArrayList不需要扩容，通过COW思想就能使数组容量满足要求。两个集合都实现了RandomAccess接口，支持随机读取，因此更加推荐使用for循环进行遍历。
Java多线程笔记
03-11
Java多线程笔记 Java多线程笔记是 Java 编程语言中关于多线程编程的笔记，涵盖了线程基础知识、线程优先级、线程状态、守护线程、构造线程、线程中断等多方面的内容。 获取简单 main 程序中的线程 在 Java 中，...
马士兵多线程笔记.zip
02-21
以下是对马士兵多线程笔记的详细解析。 1. **多线程基础**：多线程是指一个应用程序中同时执行多个线程（即任务）的能力。这种并发执行可以提高系统资源的利用率，提升程序的响应速度和执行效率，特别是在多核...
java多线程笔记
12-10
Java线程的知识点总结。doc
java中的多线程笔记
07-08
此外，多线程编程中还有一些关键概念和工具，比如线程同步和互斥机制，用于解决并发访问共享资源时可能出现的数据竞争问题。Java 提供了以下机制来保证线程安全： 1. `synchronized` 关键字：用于实现互斥访问，确保...
java多线程笔记全手打
11-06
多线程学习笔记 包含doc文档笔记加笔记中出现的代码（博文地址共上中下）http://blog.csdn.net/cloudyxuq/article/details/6941404
多线程笔记多线程笔记
09-18
使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。 一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。 Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。 一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。 一旦创建一个新的线程，就产生一个新的调用栈。 线程总体分两类：用户线程和守候线程。
多线程学习笔记（超详细笔记）
最新发布
weixin_50523986的博客
05-17 125
临时线程创建时间：新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程什么时候会开始拒绝任务核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝List itemExecutorService的常用方法新任务拒绝策略。
多线程（个人学习笔记）
qq_53120320的博客
11-10 194
多线程个人学习笔记！仅供本人使用，因为我也看不懂
"Java多线程笔记：线程状态及终止原因
Java中的多线程笔记： 在Java程序中，线程的状态有以下几种：New、Runnable、Blocked、Waiting、Timed Waiting和Terminated。线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值