【JavaEE初阶 -- 多线程2】

最新推荐文章于 2024-08-24 22:01:16 发布
最新推荐文章于 2024-08-24 22:01:16 发布
阅读量1.1k 收藏 38
点赞数 33
分类专栏： Java EE 文章标签： java-ee java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63440113/article/details/136677178
版权

这里写目录标题

1.线程安全

1.1 什么是线程安全

某个代码在单线程下执行没有任何问题，在多线程下执行出现bug。

1.2 原子性

把代码比如一个房间，每个线程就是要进入这个房间的人。如果没有任何保护机制，A进入之后，进行一些列隐私操作，然后B也可以进入房间，从而打断A，这样就是不具备原子性的。把线程A进入房间的一系列操作进行打包成一个整体进行上锁，其他线程就进不来，这样就保证了代码的原子性。

1.3 线程不安全的原因

  • 根本原因：操作系统上的线程是随即调度、抢占式执行的，线程之间执行的顺序带来了很多变数。
  • 代码结构：代码中多个线程，同时修改一个变量（一个线程修改，一个线程读也可能存在问题）。
  • 直接原因：多线程的修改操作下，本身不是原子的，一条Java语句不一定是原子的，也不一定只是一条指令，比如 i++，有三步操作：1.从内存把数据读到CPU；2.进行数据更新；3.把数据写回到CPU；
  • 多个CPU指令，一个线程执行这些指令，执行到一半被调度走，从而其他线程可能会被调度；每个CPU指令，都是原子的，要么执行完，要么不执行。
  • 内存可见性问题
  • 指令重排序问题

1.4 通过synchronized进行加锁解决线程安全问题

synchronized关键字，随便放Object对象都行，两个线程之间是否使用的是同一个对象，是同一个会产生竞争，反则是不会。进入代码块加锁，出代码块是解锁。synchronized 修饰普通方法，相当于给this加锁（锁对象是this），修饰静态方法，相当于给类对象加锁。

public class ThreadDemo19 {

    private static int count = 0;
    private static int count2 = 0;
    public static void main(String[] args) throws InterruptedException {
        // 随便创建个对象
        Object locker = new Object(); //两个线程之间是否使用的是同一个对象，是同一个会产生竞争，反则是不会
        Object locekr2 = new Object();
        // 创建两个线程，每个线程都针对上述count变量循环5w次 循环自增的代码存在线程安全问题
        int tmp = 0;
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                /*// 1）一下线程修改一个变量，没有影响
                count++;*/

                // 加锁  synchronized
                synchronized(locker) { //进入大括号 就会加锁
                    count++;
                } // 出大括号 就会解锁

                // 2）多个线程读取同一个变量，不会影响
                //System.out.println(count); //只是读取变量，变量的内容是固定不变的
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                //3）多个线程修改不同的变量，没有影响
                //count2++;
                //System.out.println(count);

                //两个线程针对不同对象加锁，存在不了锁竞争，就会出现线程安全问题
                /*synchronized (locekr2) {
                    count++;
                }*/
                synchronized (locker) {
                    count++;
                }
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();

        //打印count的结果

        System.out.println("count = "+ count);
    }
}

synchronized 加锁的效果也称为 互斥性。

class Test {
    public int count;
    // synchronized 是加到static方法上，就等价于给 类对象加锁
    /*synchronized public static void func() {

    }

    public static void func() { // 使用较少
        synchronized (Test.class) {

        }
    }*/
    // 等同于下面 synchronized (this)的代码
    /*synchronized public void add() {
        count++;
    }*/
    public void add() {
        /*synchronized (this) {
            count++;
        }*/

        // 获取Test类的对象 (在一个java进程中，一个类的类对象都是只有一个)
        // 所以在这里第一线程和第二个线程拿到的类对象是同一个类对象，因此锁竞争仍然存在能保证线程安全
        synchronized (Test.class) {
            count++;
        }
    }

}
public class ThreadDemo20 {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                test.add();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                test.add();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("count = "+test.count);
    }
}

1.5 可重入锁

可重入锁：一共就只有一把锁，同一个线程，此时锁对象就知道第二次加锁的线程就是持有锁的线程，第二次进行加锁的发现加锁线程和持有锁线程是同一个线程，即能加锁。
判定当前加锁线程是否是加锁的线程，如果不是同一个线程，阻塞；如果是同一个线程，++计数器。

public class ThreadDemo21 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t = new Thread(() -> {
            synchronized (locker) { //可重入锁：在最外层的{进行加锁 真正加锁，同时把计数器+1(初始是0，+1
                //之后就变成了1，说明当前这个对象被该线程加锁一次 )同时记录线程是谁

                //再加一个锁，当前由于是同一个线程，此时锁对象就知道了第二次加锁的线程，就是持有锁的线程
                // 第二次操作，就可以直接放行通过，不会出现阻塞   ——》这个特性 称为“可重入”
                synchronized (locker) { //第二次加锁的时候，发现加锁线程和持有锁线程是同一个线程，即能加锁
                    //成功，++计数器，如果不是同一个线程，阻塞
                    System.out.println("hello");
                } // 把计数器-1，2-1=》1，不为0.不会真的解锁
            } // 在最外层的}进行解锁  1-1=0》 进行解锁
        });
        t.start();
    }
}

1.6 死锁

加锁是解决线程安全问题，但是加锁方式不当就可能产生死锁。
死锁三种典型场景：

  1. 一个线程，一把锁，如果锁不是可重入锁，并且是一个线程对这把锁加锁两次就会出现死锁。（钥匙锁屋里了）
  2. 两个线程，两把锁，线程1获取到 锁A，线程2 获取到锁B，然后线程1 尝试获取B，线程2 尝试获取 锁A，就会出现死锁。（钥匙锁车里，车钥匙锁房间里），解决方案：约定加锁顺序，先对A进行加锁，再对B进行加锁）。
public class ThreadDemo22 {
    public static void main(String[] args) {
        Object A = new Object();
        Object B = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (A) {
                //sleep一下，给t2时间，让t2也能拿到B
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //尝试获取B，并没有释放A
                synchronized (B) {
                    System.out.println("t1拿到了两个线程");
                }
            }
        });
        /*Thread t2 = new Thread(() -> {
            synchronized (B) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //尝试获取A，并没有释放B
                synchronized (A) {
                    System.out.println("t2拿到了两个线程");
                }
            }
        });*/
        Thread t2 = new Thread(() -> {
            synchronized (A) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 解决方案：先对A进行加锁，再对B进行加锁
                synchronized (B) {
                    System.out.println("t2拿到了两个线程");
                }
            }
        });
        t1.start();
        t2.start();
    }
}
  1. N个线程，M把锁（哲学家就餐问题），解决方案：指定加锁顺序，针对五把锁，都进行编号，约定每个线程获取锁的时候，一定要先获取编号小的锁，后获取编号大的锁。

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

  1. 互斥使用：获取锁的过程是互斥的，一个线程拿到了这把锁，另一个线程也想获取，就需要阻塞 等待（锁最基本的特性，不太好破坏）
  2. 不可抢占：一个线程拿到了这把锁，只能主动解锁，不能让别的线程强行把锁抢走。（也是锁最基本的特性）
  3. 请求保持：一个线程拿到了锁A之后，在持有锁A的前提下，尝试获取锁B。（根据代码结构看实际情况可破坏）
  4. 循环等待/环路等待 （代码结构最容易破坏的）
    解决死锁问题，核心思路就是破坏上述的必要条件，破坏其一，就能解决死锁问题。只要指定一定的规则，就可以有效的避免循环等待。

1.7 Java标准库中的线程安全类

Java标准库中很多都是线程不安全的，这些类可能会涉及到多线程修改共享数据，又没有任何加锁措施。

  • ArrayList
  • LinkedList
  • HashMap
  • TreeMap
  • HashSet
  • TreeSet
  • StringBuilder

还有一些是线程安全的，使用了一些锁机制来控制：

  • Vector(不推荐使用)
  • HashTable(不推荐使用)
  • ConcurrentHashMap
  • StringBuffer
    没加锁，不涉及修改，仍然是线程安全的：
  • String

1.8 通过volatile关键字解决内存可见性引起的线程安全问题

  • volatile能够保证内存可见性；另一个功能：禁止指令重排序。
  • 什么叫内存可见性：就是高度依赖编译器的优化的具体实现
  • 如果一个线程写，一个线程读也可能存在线程安全问题

设计一个预期通过 t2 线程输入的整数，只要输入的不为0，就可以使t1线程结束。

  • 下面代码中 t2修改了内存，但是 t1没有看到这个内存的变化，即内存可见性问题。
  • 在这里的内存可见性问题：
    在多线程下，编译器对代码的优化出现了误判，本来编译器期望 把读内存操作给优化成读寄存器中缓存的值，这样优化有助于我们提高循环的执行效率，并且编译器发现没有谁来修改flag，从而进行了错误的判断，在后续通过scanner用户输入来修改flag，导致这边 t2 线程修改了，而上面 t1 线程判断flag是否为0这边没有生效，因此出现了这边不能让t1结束的bug。

原理：
解决方案：给判断的变量 添加volatile关键字，在写入的时候：

  • 改变线程工作中内存volatile变量副本的值
  • 将改变后的副本的值从工作内存刷新到主存中

在读取volatile修饰的变量的时候：

  • 从内存中读取volatile变量的最新值到线程的工作内存中
  • 从工作内存中读取volatile变量的副本
import java.util.Scanner;
public class ThreadDemo23 {
    // t2修改了内存，但是t1没有看到这个内存的变化，就称为 内存可见性 问题

    //volatile关键字 核心功能：保证内存可见性； 另一个功能：禁止指令重排序
    private volatile static int flag = 0;
    public static void main(String[] args) {
        // 预期通过t2线程输入的整数，只要输入的不为0，就可以使t1线程结束
        Thread t1 = new Thread(() -> {
           while (flag == 0) {
               // 循环体里，没有内容
               /*try {
                   // 不加sleep，一秒循环上百亿次，load操作的整体开销非常大，优化的迫切程度就更高
                   // 加了之后，一秒循环1000次，load整体开销就没这么大，优化的迫切程度就降低了
                   Thread.sleep(1);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }*/
           }
            System.out.println("t1 线程结束");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("请输入flag的值");
            Scanner scanner = new Scanner(System.in);
            flag = scanner.nextInt();
        });

        t1.start();
        t2.start();
    }
}

volatile和synchronized区别：

  • volatile保证的是内存可见性
  • synchronized保证的是原子性，也可以保证内存可见性

会出现线程安全：

// 会出现线程安全，无法保证最后结果是 100000
static class Counter {
	volatile public int count = 0;
		void increase() {
		count++;
		}
	}
	public static void main(String[] args) throws InterruptedException {
	final Counter counter = new Counter();
	Thread t1 = new Thread(() -> {
		for (int i = 0; i < 50000; i++) {
		counter.increase();
		}
	});
	Thread t2 = new Thread(() -> {
		for (int i = 0; i < 50000; i++) {
		counter.increase();
		}
	});
	t1.start();
	t2.start();
	t1.join();
	t2.join();
	System.out.println(counter.count);
}

使用synchronized，加锁，去掉volatile，给t1的循环内部加锁，并借助counter对象加锁：

static class Counter {
	public int flag = 0;
}

public static void main(String[] args) {
	Counter counter = new Counter();
	Thread t1 = new Thread(() -> {
		while (true) {
			synchronized (counter) {
				if (counter.flag != 0) {
					break;
				}
			}
			// do nothing
		}
		System.out.println("循环结束!");
	});
	Thread t2 = new Thread(() -> {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个整数:");
		counter.flag = scanner.nextInt();
	});
	t1.start();
	t2.start();
}

2. wait 和notify

由于线程之间是抢占式执行的，因此线程之间执行的先后顺序是随机的。

  • wait() / wait(long timeout): 让当前线程进入等待状态.
  • notify() / notifyAll(): 唤醒在当前对象上等待的线程.
  • 这些都是Object方法

2.1 wait() --使当前线程进行等待，释放当前锁；满足一定条件时被唤醒，重新尝试获取这个锁

wait做的事情：

  • 使当前执行代码的线程进行阻塞等待，（把线程放到等待队列中）
  • 释放当前锁
  • 满足一定条件时被唤醒，重新尝试获取这个锁

wait() 要搭配synchronized来使用，脱离synchronized使用wait会直接抛出异常。即要先有锁，才能调用wait且对象必须是同一对象。
wait结束等待的条件：

  • 其他线程调用该对象的notify方法
  • wait等待时间超时（ wait(long timeout)，来指定等待时间）
  • 其他线程调用该等待线程的 interrupted 方法, 导致 wait 抛出 InterruptedException 异常.

wait 被唤醒后也要重新参与锁竞争。

public class ThreadDemo24 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        synchronized (object) {
            System.out.println("wait 之前");
            object.wait();
            System.out.println("wait 之后");

        }
    }
}

2.2 notify()–是唤醒等待的线程

使用的哪个对象就是唤醒哪个对象的wait，如果两个wait是同一个对象调用的，随机唤醒其中一个，而notifyAll 唤醒这个对象所有等待的线程。

下面代码执行的过程：

  1. t1 执行起来之后，就会立即拿到锁，并且打印t1 wait之前，进入wait方法（释放锁+阻塞等待）
  2. t2 执行起来之后，先进行sleep（这个sleep作用是让 t1 能够先拿到锁）
  3. t2 sleep结束之后，由于t1是wait状态，锁是释放的，t2 就能拿到锁，接下来打印 t2 notify之前，执行notify操作，即唤醒t1，（此时t1就从WAITING状态恢复回来）
  4. 但是由于t2 此时还没有释放锁，t1 WAITING恢复之后，尝试获取锁，就可能会出现一个小小的阻塞，这个阻塞时由于锁竞争引起的。
  5. t2 执行完t2 notify之后，释放锁，t2 执行完毕，t1 的wait就可以获取锁，继续执行打印t1 wait之后。
public class ThreadDemo25 {
    public static void main(String[] args) {
        Object locker = new Object();

        Thread t1 = new Thread(() -> {
           synchronized (locker) {
               System.out.println("t1 wait之前");
               try {
                   // 释放锁，阻塞等待
                   locker.wait();  // 死等
                   //locker.wait(100);  带有超时的等待，ms 如果这个时间内没有进行notify，就不等
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("t1 wait之后");
           }
        });

        Thread t2 = new Thread(() -> {
            try {
                // 如果sleep写到synchronized外面的话，由于t1和t2执行顺序不确定，就可能t2先拿到锁，
                // t1 没执行到 wait  t2就先notify
                Thread.sleep(5000); // 让t1先拿到锁

                // 由于locker.wait()，锁是释放的，t2就能拿到锁
                synchronized (locker) {
                    System.out.println("t2 notify 之前");
                    // 唤醒t1，t1从WAITING 状态恢复过来
                    // 由于t2此时还没有释放锁，t1恢复之后尝试获取锁，就可能出现锁竞争从而导致阻塞
                    locker.notify();
                    System.out.println("t2 notify 之后");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
    }
}

2.3 wait 和sleep直接的区别：

  • wait提供了一个带有超时的版本，sleep也是能指定时间，都是时间到就继续执行，解除阻塞。
  • wait 和sleep 都可以被提前唤醒，wait通过notify，sleep通过interrupt唤醒
  • 使用wait 在不知道要等多久的前提下使用，所谓超时时间，即兜底的
  • 而使用sleep，要知道具体等多久，能提前唤醒，但是是异常唤醒，=。
水冠7
关注
  • 33
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
JavaEE初阶-多线程2
qq_45965652的博客
04-01 1442
线程的安全性问题以及死锁的基本介绍
JavaEE初阶---多线程编程（一.线程与进程）
2302_79862386的博客
06-07 1476
JavaEE初阶：多线程详解~~ 进程想要执行任务就需要依赖线程。换句话说，就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。
JAVAEE----多线程2
m0_58157267的博客
03-25 742
下面我们来讲一下线程的状态 我们之前说进程有就绪状态和阻塞状态,这么说其实是针对一个进程只有一个线程的情况 但其实更常见的情况是---->一个进程中包含多个线程,而所谓的状态,其实也是绑定在线程上的 我们之前说的就绪状态,阻塞状态都是针对系统层面上的线程的状态(PCB) 而在java的Thread类中,对于线程的状态又进一步的细化了 那我们下面就来看看线程状态细化后都分为哪些吧~ 3. 4. 5. 6. 我们小小的整理一下这六种状
【JavaEE学习日记】----多线程基础（上）
m0_62310210的博客
03-23 317
文章内容丰富，详细的介绍了多线程编程中的一些基础用法，Thread类常见属性和方法。 同时介绍了线程的创建，线程的终止，线程的等待，线程引用的获取以及线程的休眠
笔记14-JAVAEE之多线程初阶
12-16
【JavaEE之多线程初阶】 在JavaEE开发中，多线程是提升系统性能和并发处理能力的重要手段。本文将深入探讨多线程的基本概念、应用以及关键特性。 1. **认识线程（Thread）** 1.1 概念 - **线程是什么**：线程被...
javaee-api-8.0-javadoc.jar
10-12
javaee-api-8.0-javadoc.jar，这是javaee1.8api的jar包，解压后可用javadoc2chm制作成chm帮助文档。
笔记16-JAVAEE之多线程进阶
12-17
Java 多线程进阶 - 锁策略与读写锁 在 Java 多线程编程中，锁策略和读写锁是两个非常重要的概念。本文将对 Java 多线程进阶中的锁策略和读写锁进行详细介绍。 锁策略 在多线程编程中，锁策略是一个非常重要的概念...
javaee-api-7.0.jar
05-22
javaweb/javaEE常用jar包，亲测可用，导入到java工程中使用
javaee-api-7.0.zip
08-20
这个"javaee-api-7.0.zip"文件包含了Java EE 7规范的API文档和相关的类库，是开发者进行企业级开发的重要参考资料。Java EE 7是在2013年发布的，它引入了一系列新特性和改进，旨在提升开发效率，简化多层架构的应用...
JavaEE：http请求 | 同步与异步请求 | 跨域问题 | axios框架 有这一篇就够！
Dreamkidya的博客
08-18 922
HTTP请求是现代Web开发中前后端沟通的基础。在开发过程中，开发者面临同步与异步请求的选择、跨域问题的挑战以及选择合适的HTTP库等问题。同步请求简单却往往阻塞用户界面，而异步请求能提高效率但增加复杂性。跨域问题则源自浏览器的同源政策，常常需要特定的解决方案。在众多HTTP库中，axios因其简单易用和功能丰富而受到欢迎。它支持Promise，适合异步请求，同时内置了请求和响应拦截器、请求取消和JSON数据处理等功能。
《javaEE篇》--定时器
hyldzbg的博客
08-21 941
当我们不需要某个线程立刻执行，而是在指定时间点或指定时间段之后执行，假如我们要定期清理数据库里的一些信息时，如果每次都手动清理的话就太麻烦，所以就可以使用定时器。定时器就可以比作一个闹钟，可以让我们的线程在指定的时间执行，还可以指定时间循环执行。
[JavaEE] 工作流- Activiti7 框架详解
m0_64307465的博客
08-22 1347
目前业界流行的工作流技术有JBPM、Activiti、Flowable、Camunda，其中以Activiti占有率为最高Activiti是一个开源的轻量级工作流引擎，2010年基于jBPM4实现首次开源。Activiti可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言BPMN进行定义BPMN是一种用于图形化表示和描述业务流程的标准化标记语言，目前主流的版本是2.0。
【JavaEE】文件操作
2302_79806056的博客
08-24 621
在深入学习Java中的文件操作之后，我对文件读写、文件流、路径处理等方面有了更深刻的理解。通过实践和探索，我对文件操作有了更全面的认识。通过这次学习，我对Java中的文件操作有了更深刻的理解，并认识到在实际应用中需要综合考虑多种因素。在未来的开发工作中，我将继续深入研究这些知识点，并努力将它们应用到实践中去。学习文件操作不仅提高了我的编程技能，还让我意识到了在设计文件处理程序时需要考虑的诸多因素。以上，就是本期的全部内容啦，若有错误疏忽希望各位大佬及时指出💐。
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 61
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 500
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1039
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 688
linux上datax 安装以及使用
二叉树(源码+lw+部署文档+讲解等)
lpw1012的博客
08-21 720
🌞博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序技术领域和毕业项目实战，以及程序定制化开发、全栈讲解、就业辅导✌🌞👇🏻精彩专栏 推荐订阅👇🏻2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅Java精品实战案例《500套》
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值