Java多线程--锁使用

已于 2023-02-21 14:25:57 修改
阅读量529 收藏
点赞数
分类专栏： java 文章标签： java jvm 开发语言
于 2022-12-28 20:16:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43457781/article/details/128448611
版权

一、一些概念

1、线程同步

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

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

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

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

2、死锁

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

        下列是死锁情况。解决办法：嵌套的synchronized拆出来。


public class CopyOnWriteArrayListTest {
    public static void main(String[] args) throws InterruptedException {
        UseObjec useObjec1=new UseObjec(false);
        UseObjec useObjec2=new UseObjec(true);

        useObjec1.start();
        useObjec2.start();
    }
}

class ObjOne{

}
class  ObjTwo{

}

class UseObjec extends Thread{
    static ObjOne objOne=new ObjOne();
    static ObjTwo objTwo=new ObjTwo();

    private Boolean flag;

    UseObjec(){

    }

    UseObjec(Boolean flag){
        this.flag=flag;
    }

    @Override
    public void run(){
        useMethod();
    }

    private void useMethod(){
        if(flag==true){
            synchronized (objOne){
                System.out.println(Thread.currentThread().getName()+"使用对象1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (objTwo){
                    System.out.println(Thread.currentThread().getName()+"使用对象2");

                }
            }
        }else {
            synchronized (objTwo){
                System.out.println(Thread.currentThread().getName()+"使用对象2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (objOne){
                    System.out.println(Thread.currentThread().getName()+"使用对象1");

                }
            }
        }
    }
}

3、Lock（锁）

        Java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象。

        ReetranLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

import java.util.concurrent.locks.ReentrantLock;

public class CallabaleTest {

    public static void main(String[] args) {
        ReentrantLockTest reentrantLockTest=new ReentrantLockTest();

        new Thread(reentrantLockTest).start();
        new Thread(reentrantLockTest).start();
        new Thread(reentrantLockTest).start();
    }
}

class ReentrantLockTest implements Runnable{
    static Integer tick=10;

    private final ReentrantLock reentrantLock=new ReentrantLock();

    @Override
    public void run() {
        try{
            //上锁
            reentrantLock.lock();
            while (true){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(tick>0){
                    System.out.println(tick--);
                }else {
                    break;
                }
            }
        }finally {
            //释放锁
            reentrantLock.unlock();
        }
    }
}

二、线程通信

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

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

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

          synchronized不能用来实现不同线程之间的消息传递

Java提供解决线程之间通信的方法：

1、管程法（生产者/消费者模式）

        生产者：负责生产数据的模块；

        消费者：负责处理数据的模块；

        缓冲区：消费者不能直接使用生产者的数据，在他们之间有个缓冲区。

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

public class PipelineTest {
    public static void main(String[] args) {
        BufferZone bufferZone=new BufferZone();

        new Produce(bufferZone).start();
        new Consumer(bufferZone).start();
    }
}

//生产者
class Produce extends Thread{
    private BufferZone bufferZone;

    public Produce(BufferZone bufferZone){
        this.bufferZone=bufferZone;
    }

    @Override
    public void run(){
        for (int i = 0; i <100; i++) {
            System.out.println("造一个,id:"+i);
            bufferZone.push(new Producers(i));
        }
    }

}

//消费者
class Consumer extends Thread{
    private BufferZone bufferZone;

    public Consumer(BufferZone bufferZone){
        this.bufferZone=bufferZone;
    }

    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            Producers use = bufferZone.use();
            System.out.println("用了一个,id:"+use.getId());
        }
    }
}

//产品
class Producers{
    private Integer id;

    public Producers(Integer id){
        this.id=id;
    }

    public Integer getId() {
        return id;
    }
}

//缓冲区
class BufferZone{
    //容器
    Producers[] producers=new Producers[10];

    //容器大小
    int size=0;

    //生产产品
    public synchronized void push(Producers producer){
        if(size==producers.length){
            //缓存区满了，停止生产
        }else {
            producers[size]=producer;
            size++;
        }
    }

    //消费产品
    public synchronized Producers use(){
        //缓冲区有东西，消费
        if(size==0){
        }
        size--;
        return producers[size];
    }


}

    

2、信号灯法

       角色：生产者、消费者、产品

        主要使用方法：wait()、notifyAll()

public class PipelineTest {
    public static void main(String[] args) {
        Producers bufferZone=new Producers();

        new Produce(bufferZone).start();
        new Consumer(bufferZone).start();
    }
}

//生产者
class Produce extends Thread{
    private Producers bufferZone;

    public Produce(Producers bufferZone){
        this.bufferZone=bufferZone;
    }

    @Override
    public void run(){
        for (int i = 0; i <10; i++) {
            bufferZone.play("节目"+i);
        }
    }

}

//消费者
class Consumer extends Thread{
    private Producers bufferZone;

    public Consumer(Producers bufferZone){
        this.bufferZone=bufferZone;
    }

    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            bufferZone.watch();
        }
    }
}

//产品
class Producers{
    private String name;
    private  Boolean flag=true;

    //展示
    public synchronized void play(String name){
        //如果观众在观看就等待
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name=name;
        System.out.println("表演"+name);

        //通知观看
        this.notifyAll();//唤醒
        //转置信号
        this.flag=!this.flag;

    }

    //观看
    public synchronized void watch(){
        //如果没有界面就等待
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("展示：：："+name);
        //通知表演
        this.notifyAll();
        //转置信号
        this.flag=!this.flag;

    }
}

3、线程池

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

思路：提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建

           销毁、实现重复利用。

好处：提高相应速度

           降低资源消耗

           便于线程管理：corePoolSize：核心池的大小

                                    maximumPoolSize：最大线程数

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

Java提供的线程池相关类：ExecutorService、Executors

        ExecutorService：线程池接口。

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

                <T> Future<T> submit(Callable<T> task)：执行任务，有返回值。

                void shutdown()：关闭连接池

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

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolTest {
    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(3);

        service.execute(new PoolRunnableTest());
        service.execute(new PoolRunnableTest());
        service.execute(new PoolRunnableTest());
        service.execute(new PoolRunnableTest());
        service.execute(new PoolRunnableTest());

        service.shutdown();
    }
}

class PoolRunnableTest implements Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"666");
    }
}

二、案例

1、CopyOnWriteArrayList（安全的集合）

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListTest {
    public static void main(String[] args) throws InterruptedException {
        //list不安全
        List<String> list=new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                list.add("");
            }).start();
        }
        //list很大几率不会等于1000
        System.out.println(list.size());

        //安全的集合
        CopyOnWriteArrayList<String> listForSafe=new CopyOnWriteArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                listForSafe.add("");
            }).start();
        }
        //此处打印可能不到1000，因为主线程跑完，子线程还未执行完毕
        //listForSafe等于1000
        System.out.println(listForSafe.size());
    }
}

两年半.倸枸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程并发解决方案-分布式锁
weixin_38376791的博客
09-03 756
分布式锁 基于Redis 1.可以使用Redisson实现分布式锁； @SpringBootTest class DemoApplicationTests { @Resource private Redisson redisson; @Resource private RedisTemplate redisTemplate; @Test public void deductStock() { //获取锁 String
JAVA采用多种方式实现多线程编程（Synchronized、Reentrantlock、Redis的分布式锁、Actor模型）
qq_46135702的博客
12-06 985
当涉及到多线程环境下的账户转账操作时，需要确保数据一致性和并发安全。以下是JAVA采用多种方式（Synchronized、Reentrantlock、Redis的分布式锁、Actor模型）实现多线程下账户转账的示例代码：
Java多线程及锁的简单介绍
xx的博客
11-14 498
Java多线程及锁简介
Java多线程锁
Yellow_Star的博客
07-26 448
本专栏学习内容又是来自有兴趣的小伙伴可以点击视频地址观看。
Java中如何实现分布式锁，详细教程来啦~
smilehappiness的博客
08-02 1941
创作不易，如果觉得这篇文章对你有帮助，欢迎各位老铁点个赞支持下呗，您的支持是我创作的最大动力！ 文章目录1 前言2 什么是分布式架构2.1 基础概念2.2 集群部署和分布式部署的区别2.3 分布式架构带来哪些问题2.3.1 分布式架构需要解决的问题2.3.2 CAP理论3 锁的分类4 实现分布式锁4.1 为什么要使用分布式锁4.2 实现分布式锁的几种方式4.2.1 基于Zookeeper实现分布式锁4.2.2 基于Redis实现分布式锁4.2.3 基于数据库实现分布式锁 1 前言 随着时代的变化，Jav.
java多线程-读写锁原理
09-01
在Java多线程编程中，读写锁是一种高级的同步机制，它允许多个线程同时读取共享资源，但只允许一个线程写入。这种锁的引入提高了并发性能，特别是在读操作远多于写操作的场景下。Java 5开始，`java.util.concurrent....
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程同步是一种解决并发问题的关键技术。当多个线程同时访问共享资源时，可能会引发数据不一致性和竞态条件。线程同步的主要目标是确保同一时间只有一个线程能够访问特定的代码段，以避免数据损坏...
Java多线程-线程的生命周期
最新发布
01-27
Java多线程中，线程的生命周期是编程中必须理解的重要概念。在JDK1.5之前，线程被划分为五个状态，分别是新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）。在JDK1.5及之后，线程的...
java 多线程-锁详解及示例代码
09-01
Java 多线程编程中，锁机制是保证并发安全的关键技术。本文主要讲解了Java中锁的基本概念、使用方式以及示例代码，旨在帮助开发者...通过阅读本文和尝试相关示例代码，开发者可以深入理解Java多线程中锁的使用和原理。
java 多线程-线程通信实例讲解
09-01
Java 多线程是并发编程中的重要概念，它允许程序同时执行多个任务，提升系统效率。线程通信是多线程编程中一个关键的组成部分，它确保线程间能有效地协同工作，避免竞争条件和死锁等问题。在Java中，线程通信主要...
由浅入深详解四种分布式锁
2301_76725413的博客
08-18 516
分布式锁是由于单机锁无法满足分布式系统锁，在分布式环境下，需要分布式锁来控制共享内容，保证线程的安全。分布式满足几个特性互斥性超时释放锁自动续期分布式锁实现方式Mysql使用排它锁，。实现比较简单，但是数据库无法支撑大量请求访问，性能较差。Zookeeper先创建一个持久类型的节点，当多个线程请求时，在持久类型节点创建顺序临时节点，先判断自己是否是最小节点，如果是持有锁，执行后续逻辑，如果不是就找到上一个顺序节点，并添加watch监听事件。线程处理结束后。
java多线程之锁简述
quzhiyuan9的博客
07-31 97
java多线程中锁的概述
Java多线程（ Thread & Runnable）& Java同步代码块、同步方法、Lock锁
weixin_43294854的博客
06-14 374
实现多线程方式一:(继承Thread类) 1.创建Thread的子类，并重写run()方法； run():该方法体代表线程要完成的任务。（线程执行体） 2.调用start()方法执行线程 代码： public class MyThread extends Thread { //重写run方法设置线程任务 @Override public void run() { for (int i = 0; i <20 ; i++) { Sys
JAVA如何在线程中加锁（四种方法）
热门推荐
weixin_43907440的博客
04-22 2万+
JAVA多线程锁 线程的生命周期 ​ 总共六种状态，可归结为五种，线程的最终是死亡，阻塞不是最终状态，只是一个临时状态。只有调用了start方法，线程才进入就绪阶段。 //新生 ​ NEW, //运行​ RUNNABLE, //阻塞​ BLOCKED, //等待，死死地等​ WAITING, //超时等待​ TIMED_WAITING, //终止​ ...
JAVA基础-多线程中锁机制
骑牛小道士
11-22 2247
JAVA基础-多线程锁机制
多线程高并发场景下为什么需要锁
qq_41194023的博客
04-24 1730
如果线程A执行完了x=x+1的操作，但还没有来得及将修改后的值写入内存中，此时线程B先执行了x=x-1的操作，那么最终x的值就是原始值，而不是应该的值。4.StampedLock：StampedLock是Java中提供的一种乐观锁，它采用了乐观锁和悲观锁相结合的方式实现同步，可以在保证线程安全的同时提高程序的并发性。虽然锁会引入一定的开销，但是在多线程高并发的情况下，使用锁可以避免线程之间的竞争，从而提高程序的性能和效率。在Java语言中，提供了多种类型的锁，每种锁都有其特定的应用场景和使用方式。
Java多线程加锁例子
qq_30603317的博客
09-15 1104
Java多线程加锁例子一、错误示例二、正确示例 一、错误示例 static int a = 0; //多线程同时操作 val a @Test public void test4() throws InterruptedException { Runnable runnable = () -> { while (a < 10) { a++; System.out.print(a + "\t"); }
SpringBoot实战实现分布式锁一之重现多线程高并发场景
weixin_34418883的博客
12-10 5238
实战前言：上篇博文我总体介绍了我这套视频课程：“SpringBoot实战实现分布式锁” 总体涉及的内容，从本篇文章开始，我将开始介绍其中涉及到的相关知识要点，感兴趣的小伙伴可以关注关注学习学习！！工欲善其事，必先利其器，介绍分布式锁使用的前因后果之前，得先想办法说清楚为啥需要分布式锁以及如何才需要将分布式锁搬上用场！！其中，该课程的学习链接：http://edu.51cto.com/course/...
Java_多线程、并发控制、分布式锁、存储结构、消息队列常见问题
煮面要加牛奶的博客
04-05 458
文章目录1. synchronize 和 lock的区别2. 多线程的状态流转、等待和阻塞的区别3. zookeeper 角色4. 分布式锁的原理5. redis的分布式方式6. redis存储的内部数据结构7. redis通过什么方式实现主从复制8. MySQL为什么选择B+树，不选择B树9. nsq和kafka的使用场景，不同点，以及不同的场景怎么选择 1. synchronize 和 lock的区别 2. 多线程的状态流转、等待和阻塞的区别 3. zookeeper 角色 4. 分布式锁的原理 5.
Java多线程编程-使用线程的缺点
05-26
使用线程的缺点主要有以下几点： 1. 资源竞争：多个线程共享同一资源时，可能会发生资源竞争的情况，导致数据不一致或者程序出现异常。 2. 上下文切换开销：线程之间的切换需要保存和恢复上下文信息，这个过程需要消耗一定的系统资源，如果线程数量过多，会导致系统性能降低。 3. 线程安全：多个线程同时访问共享资源时，需要考虑线程安全的问题，需要采用锁、同步等机制来保证数据的一致性和正确性，这会增加代码的复杂度。 4. 调试困难：多线程程序的调试比单线程程序复杂，因为多个线程之间的相互影响可能导致程序的错误行为。 5. 可靠性降低：线程之间的协作关系比较复杂，如果不正确地使用线程，可能会导致程序崩溃或者死锁等问题，从而影响程序的可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值