线程同步机制

最新推荐文章于 2024-01-06 15:26:36 发布
最新推荐文章于 2024-01-06 15:26:36 发布
阅读量235 收藏 1
点赞数
分类专栏： 学习考研 文章标签： 多线程 java 编程语言 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42832437/article/details/106820573
版权
1. 线程安全问题
1.1 概念

在这里插入图片描述

1.2 线程安全问题的代码实现
package cn.itcast.day12.demo03;
//实现卖票案例
public class RunnableImpl implements Runnable {
    //定义一个多线程共享的票源
    private int ticket = 20;

    //设置线程任务，卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行
        while(true){
            //先判断票是否存在
            if(ticket > 0){
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                ticket --;
            }
        }


    }
}

主函数

package cn.itcast.day12.demo03;

public class Ticket {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

执行结果

Thread-0-->正在卖第20张票
Thread-2-->正在卖第20张票
Thread-1-->正在卖第20张票
Thread-2-->正在卖第17张票
Thread-0-->正在卖第17张票
Thread-1-->正在卖第17张票
Thread-0-->正在卖第14张票
Thread-2-->正在卖第14张票
Thread-1-->正在卖第14张票
Thread-1-->正在卖第11张票
Thread-2-->正在卖第11张票
Thread-0-->正在卖第11张票
Thread-0-->正在卖第8张票
Thread-1-->正在卖第8张票
Thread-2-->正在卖第8张票
Thread-1-->正在卖第5张票
Thread-0-->正在卖第5张票
Thread-2-->正在卖第5张票
Thread-1-->正在卖第2张票
Thread-0-->正在卖第2张票
Thread-2-->正在卖第2张票
Thread-1-->正在卖第-1张票
1.3 线程安全问题产生的原理

在这里插入图片描述

2. 解决线程安全问题

为了保证每个线程都能正常执行原子操作Java引入了线程同步机制。
那么怎么去使用呢?有三种方式完成同步操作:

  1. 同步代码块。
  2. 同步方法。
  3. 锁机制。
2.1 同步代码块

同步代码块: synchronized关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。
格式:

synchronized(同步锁){
需要同步操作的代码
}

注意:

  1. 通过代码块中的锁对象,可以使用任意的对象
  2. 但是必须保证多个线程使用的锁对象是同一-个
  3. 锁对象作用:
    把同步代码块锁住,只让一-个线程在同步代码块中执行
package cn.itcast.day12.demo03;
//实现卖票案例
public class RunnableImpl implements Runnable {
    //定义一个多线程共享的票源
    private int ticket = 20;
    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务，卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行
        while(true){
           //同步代码块
           synchronized (obj){
               if(ticket > 0){
                   //提高安全问题出现的概率，让程序睡眠
                   try {
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                   ticket --;
               }
           }
        }
    }
}

主函数

package cn.itcast.day12.demo03;

public class Ticket {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

执行结果

Thread-0-->正在卖第20张票
Thread-0-->正在卖第19张票
Thread-2-->正在卖第18张票
Thread-1-->正在卖第17张票
Thread-1-->正在卖第16张票
Thread-1-->正在卖第15张票
Thread-1-->正在卖第14张票
Thread-1-->正在卖第13张票
Thread-1-->正在卖第12张票
Thread-1-->正在卖第11张票
Thread-1-->正在卖第10张票
Thread-1-->正在卖第9张票
Thread-1-->正在卖第8张票
Thread-1-->正在卖第7张票
Thread-1-->正在卖第6张票
Thread-1-->正在卖第5张票
Thread-2-->正在卖第4张票
Thread-2-->正在卖第3张票
Thread-2-->正在卖第2张票
Thread-2-->正在卖第1张票

同步技术原理
在这里插入图片描述

2.2 同步方法

使用步骤:

  1. 把访问了共享数据的代码抽取出来,放到一个方法中
  2. 在方法上添加synchronized修饰符

格式：定义方法的格式

修饰符synchronized 返回值类型方法名(参数列表){
可能会出现线程安全问题的代码(访问了共享数据的代码)

package cn.itcast.day12.demo03;
//实现卖票案例
public class RunnableImpl2 implements Runnable {
    //定义一个多线程共享的票源
    private int ticket = 20;

    //设置线程任务，卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行
        while (true) {

            payTicket();
        }
    }
        //定义一个同步方法
    public synchronized void payTicket(){

            if(ticket > 0){
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                ticket --;
            }
        }
    }

主函数

package cn.itcast.day12.demo03;

public class Ticket2 {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImpl2 run = new RunnableImpl2();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

执行结果

Thread-0-->正在卖第20张票
Thread-0-->正在卖第19张票
Thread-1-->正在卖第18张票
Thread-1-->正在卖第17张票
Thread-1-->正在卖第16张票
Thread-1-->正在卖第15张票
Thread-1-->正在卖第14张票
Thread-1-->正在卖第13张票
Thread-1-->正在卖第12张票
Thread-1-->正在卖第11张票
Thread-1-->正在卖第10张票
Thread-1-->正在卖第9张票
Thread-1-->正在卖第8张票
Thread-1-->正在卖第7张票
Thread-1-->正在卖第6张票
Thread-1-->正在卖第5张票
Thread-1-->正在卖第4张票
Thread-1-->正在卖第3张票
Thread-1-->正在卖第2张票
Thread-1-->正在卖第1张票
2.3 Lock锁

解决线程安全问题的第三种方案:使用Lock锁
java. util. concurrent. locks.Lock接口
Lock实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作。
Lock接口中的方法:
void lock( );获取锁。
void unLock();释放锁。
java. util. concurrent . Locks . ReentrantLock implements Lock接口
使用步骤:

  1. 在成员位置创建一-个ReentrantLock对象
  2. 在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
  3. 在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
package cn.itcast.day12.demo03;

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

//实现卖票案例
public class RunnableImpl3 implements Runnable {
    //定义一个多线程共享的票源
    private int ticket = 20;
    //1. 在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();


    //设置线程任务，卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行
        while(true){
           //2. 在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
           l.lock();
               if(ticket > 0){
                   //提高安全问题出现的概率，让程序睡眠
                   try {
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                   ticket --;
               }
               //3. 在可能出现安全问题的代码后调用lock接口中的unlock释放锁
            l.unlock();
           }
        }
    }

主函数

package cn.itcast.day12.demo03;

public class Ticket3 {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImpl3 run = new RunnableImpl3();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

执行结果

Thread-0-->正在卖第20张票
Thread-1-->正在卖第19张票
Thread-1-->正在卖第18张票
Thread-1-->正在卖第17张票
Thread-1-->正在卖第16张票
Thread-1-->正在卖第15张票
Thread-1-->正在卖第14张票
Thread-1-->正在卖第13张票
Thread-1-->正在卖第12张票
Thread-1-->正在卖第11张票
Thread-1-->正在卖第10张票
Thread-1-->正在卖第9张票
Thread-1-->正在卖第8张票
Thread-1-->正在卖第7张票
Thread-1-->正在卖第6张票
Thread-1-->正在卖第5张票
Thread-1-->正在卖第4张票
Thread-1-->正在卖第3张票
Thread-1-->正在卖第2张票
Thread-1-->正在卖第1张票

另一种高效的锁机制代码

建议总是立即实践，使用lock 块来调用try, 在之前/之后的构造中，最典型的代码如下:
class X {
   private final Reent rantLock lock = new Reent rantLock () ;
// ...
   public void m() {
     lock. lock(); // block until condition holds
     try {
// ... method body
     }finally {
      lock. unlock ()
    }
  }
}
孤鸿末子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程同步机制_动力节点Java学院整理
08-30
在之前，已经学习到了线程的创建和状态控制，但是每个线程之间几乎都没有什么太大的联系。可是有的时候，可能存在多个线程多同一个数据进行操作，这样，可能就会引用各种奇怪的问题。现在就来学习多线程对数据访问的...
（学习笔记-进程管理）多线程冲突如何解决
dx1313113的博客
08-11 1057
对于共享资源，如果没有上锁，在多线程的环境里，很有可能发生翻车。
五招解决 多(线程)进程中如何避免竞争，进行互斥
lai_zhe的博客
07-27 2942
多(线程)进程中如何避免竞争，进行互斥 首先先引进临界区的概念： 我们把对共享内存进行访问的内存片段称作临界区域或临界区（critical region）。 如何避免竞争，需要满足以下四个条件 任何两个进程（线程）不能同时处于其临界区 不应该对CPU的速度和数量做任何假设 临界区外运行的进程不得阻塞其他进程 不得使进程无限期等待进入临界区 参考书籍：现在操作系统第四版 进程域线程 互斥的五种方法 屏蔽中断 使进程刚刚进入临界区时立即屏蔽所有中断，并在离开时打开中断。CPU只有发生时钟中断或其他
【多线程】| 线程冲突解决方案
狮子也疯狂的博客
05-22 1840
同一进程内的线程是共享同一内存空间的，所以在多个线程的进程里，线程是可以同时操作这个进程空间的数据的，这样就容易造成线程冲突的情况。举个小李子：一个房子里（代表一个进程），只有一个厕所（代表一个资源）。屋子里面有两个人A和B（代表两个线程），共用这个厕所。一天A去上厕所了，一上就仨小时。到第三个小时的时候，B实在忍不住了，直接就开门进去把在里面玩手机的A轰了出来。然后A就被赶出来了，嘴里骂骂咧咧……这里说明了什么呢？？？
优化多线程数据访问，避免重复访问
博客
10-07 1162
本文介绍了优化多线程数据访问的问题，并提出了三种常见的解决方案：使用锁机制、使用缓存机制和使用信号量机制。同时，还介绍了综合使用这些解决方案的方法，并通过一个实践案例展示了优化多线程访问数据库的效果。优化多线程数据访问是提高程序性能和数据一致性的重要环节。选择合适的解决方案，根据具体情况进行调优，可以提高多线程数据访问的效率和可靠性。
多线程冲突的解决——锁
weixin_45627369的博客
07-17 2147
多个线程可以共享该进程对应的资源，所以需要加锁保证多线程在共享资源时，只有一个线程能访问，避免因资源竞争而导致数据错乱锁的选择加锁的成本开销分析业务场景中访问共享资源的方式考虑并发访问共享资源时的冲突概率。......
java的线程同步机制synchronized关键字的理解_.docx
10-09
Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...
Java多线程同步机制研究分析.pdf
12-27
Java多线程同步机制研究分析 Java多线程同步机制是Java编程语言中的一种机制，它允许多个线程同时执行，提高了系统资源的利用率和安全性。但是，多线程中最重要的问题是线程的同步和共享资源的访问保护。本文通过对...
linux线程同步
06-13
介绍了linux线程同步的所有方式，包括互斥、自旋、信号量、条件变量等技术
多线程冲突处理方法，锁
weixin_66455428的博客
04-11 1258
多线程冲突处理方法，锁
Java并发常见面试题（三）
m0_51431003的博客
12-06 846
作用于非静态方法，锁住的是对象实例（this），每一个对象实例有一个锁。作用于静态方法，锁住的是类的 Class 对象，Class 对象全局只有一份，因此静态方法锁相当于类的一个全局锁，会锁所有调用该方法的线程。作用于 Lock.class，锁住的是 Lock 的 Class 对象，也是全局只有一个。作用于 this，锁住的是对象实例，每一个对象实例有一个锁。作用于静态成员变量，锁住的是该静态成员变量对象，由于是静态变量，因此全局只有一个。必须有“对象”来充当“锁”的角色。
多线程冲突了怎么办？
sunriseYJP的博客
07-27 189
操作系统为每一个进程创建巨大、私有的虚拟内存的假象，这种地址空间的抽象让每个程序觉得自己好像拥有自己的内存，但是实际上操作系统在背后让多个地址空间复用物理内存或者是磁盘。寄存器是CPU的上下文环境，线程1运行的时候，它将i的值从内存中加载到它的寄存器中，然后在寄存器中+1，如果多个线程竞争的是共享资源，如果不采取有效措施，会造成共享数据的混乱。我们做个小实验，创建两个线程，它们分别对共享变量。次，结果不是20000。
【Java后台开发规范】--- 线程与并发
自律使我自由
11-24 808
文章目录前言其他类型的规范线程池线程安全时间数值集合MapListSet线程并发分段锁随机数ConcurrentHashMap读写锁ReentrantReadWriteLock写时复制CopyOnWriteArrayList伪共享ThreadLoad 前言 做Java开发的，大多数可能都有看过阿里的Java后台开发手册，里面有关于Java后台开发规范的一些内容，基本覆盖了一些通用、普适的规范，但大多数都讲的比较简洁，本文主要会用更多的案例来对一些规范进行解释，以及结合自己的经验做补充！ 其他类型的规范 【J
synchronized与（ReentrantLock）Lock的对比区别
天青色等烟雨
06-29 948
类别 synchronized Lock 存在层次 Java关键字，属于原生语法层面需要jvm实现 而Lock它是JDK 1.5之后提供的API层面的互斥锁，需要lock()和unlock()方法配合try/finally语句块来完成 锁的释放 1.以获取锁的线程执行完同步代码块，释放锁 2.线程执行发生异常，jvm会让线程释放...
【Java】Java多线程：数据一致性问题及解决方案
wjianwei666的专栏
01-06 783
例如，如果两个线程同时对同一个变量进行增加操作，最终的结果可能不是预期的两倍值，因为两个线程可能会读取同一个旧值，然后各自增加后写回，导致其中一个线程的修改被覆盖。在面向对象的编程语言Java中，多线程编程是一个强大的工具，可以使我们能够构建高效率和高并发的应用程序。java.util.concurrent.atomic包提供了一组原子类，例如AtomicInteger、AtomicLong等，它们使用高效的机器级指令（例如compare-and-swap）来保证单个变量操作的原子性。
多服务环境下定时任务重复执行问题解决方案
拥抱白菜的猪博客
06-05 4240
当一个服务部署在多台服务器上时，定时任务可能出现多次执行的情况，就是每个服务上执行一次。有以下两种思路，一是固定死只有某服务器执行定时任务，二是随机暂停几秒，某一服务执行了，其他就不再执行。
多节点服务器定时任务重复的一种解决方式
weixin_44699728的博客
11-10 4405
乐观锁和悲观锁 悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它释放锁。 乐观锁：总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。 锁实现 新建表： CREATE TABLE `schedule_execute_info` ( `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增主键..
java 多线程 同步机制
最新发布
06-03
为了避免这种情况，Java提供了同步机制，即synchronized关键字和Lock接口。 synchronized关键字可以修饰方法或代码块，保证在同一时刻只有一个线程可以访问被修饰的方法或代码块。例如： ``` public synchronized ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值