线程同步机制（synchronized和Lock）

最新推荐文章于 2022-06-26 17:14:24 发布
最新推荐文章于 2022-06-26 17:14:24 发布
阅读量809 收藏 1
点赞数 1
文章标签： 区块链 java rust
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Valentino112358/article/details/90051227
版权

线程安全问题

多线程访问了共享数据 ，引发了线程安全问题。

线程安全问题的代码实现

package com.itheima.demo06.ThreadSafe;
/*
    实现卖票案例
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;
    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true)
        {
            //先判断票是否存在
            if(ticket>0)
            {
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

实现

创建3个线程,同时开启,对共享的票进行出售
package com.itheima.demo06.ThreadSafe;
/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    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-2-->正在卖第100张票
Thread-0-->正在卖第100张票
Thread-1-->正在卖第100张票
Thread-2-->正在卖第97张票
Thread-0-->正在卖第96张票
Thread-1-->正在卖第96张票
Thread-2-->正在卖第94张票
Thread-1-->正在卖第93张票
Thread-0-->正在卖第93张票
Thread-2-->正在卖第91张票
Thread-0-->正在卖第90张票

会出现同时卖一张票的情况。 

同步代码块（解决方法1）

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

卖票案例出现了线程安全问题
卖出了不存在的票和重复的票

解决线程安全问题的一种方案:使用同步代码块
格式:
    synchronized(锁对象){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
    }

注意:
    1.通过代码块中的锁对象,可以使用任意的对象
    2.但是必须保证多个线程使用的锁对象是同一个，所以必须在run外面创建
    3.锁对象作用:
        把同步代码块锁住,只让一个线程在同步代码块中执行
package com.itheima.demo07.Synchronized;
/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的一种方案:使用同步代码块
    格式:
        synchronized(锁对象){
            可能会出现线程安全问题的代码(访问了共享数据的代码)
        }

    注意:
        1.通过代码块中的锁对象,可以使用任意的对象
        2.但是必须保证多个线程使用的锁对象是同一个
        3.锁对象作用:
            把同步代码块锁住,只让一个线程在同步代码块中执行
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();//但是必须保证多个线程使用的锁对象是同一个

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

格式:
        synchronized(锁对象){
            可能会出现线程安全问题的代码(访问了共享数据的代码)
        }

实现，创建3个线程,同时开启,对共享的票进行出售

package com.itheima.demo07.Synchronized;

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    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-->正在卖第100张票
Thread-0-->正在卖第99张票
Thread-0-->正在卖第98张票
Thread-0-->正在卖第97张票
Thread-0-->正在卖第96张票
Thread-0-->正在卖第95张票
Thread-0-->正在卖第94张票
Thread-0-->正在卖第93张票
Thread-0-->正在卖第92张票
Thread-0-->正在卖第91张票
Thread-0-->正在卖第90张票
Thread-0-->正在卖第89张票
Thread-0-->正在卖第88张票
Thread-0-->正在卖第87张票
Thread-0-->正在卖第86张票
Thread-0-->正在卖第85张票
Thread-0-->正在卖第84张票
Thread-0-->正在卖第83张票
Thread-0-->正在卖第82张票
Thread-0-->正在卖第81张票
Thread-0-->正在卖第80张票
Thread-0-->正在卖第79张票
Thread-0-->正在卖第78张票

不再发生冲突。

同步的原理

 有锁对象则执行，没有锁对象则进入阻塞状态，等待其他线程归还锁对象。obj锁对象只有一个。

保证只能有一个线程在同步中执行共享数据。

同步方法（解决方法2）

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外 等着。

package com.itheima.demo08.Synchronized;
/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的二种方案:使用同步方法
    使用步骤:
        1.把访问了共享数据的代码抽取出来,放到一个方法中
        2.在方法上添加synchronized修饰符

    格式:定义方法的格式
    修饰符 synchronized 返回值类型 方法名(参数列表){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
    }
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;
    //设置线程任务:卖票
    @Override
    public void run() {
        System.out.println("this:"+this);//this:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
        //使用死循环,让卖票操作重复执行
        while(true){
            payTicket();
        }
    }
    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁?
        就是实现类对象 new RunnableImpl()
        也是就是this
     */
    public synchronized void payTicket(){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
    }
}

同步方法的锁对象是谁?
就是实现类对象 new RunnableImpl()
也是就是this，只有一个锁对象。

package com.itheima.demo08.Synchronized;

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        System.out.println("run:"+run);//run:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);   // 三个中的this是同一个对象 和上面创建的run也是同一个
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

执行结果：

run:com.itheima.demo08.Synchronized.RunnableImpl@48140564
this:com.itheima.demo08.Synchronized.RunnableImpl@48140564
this:com.itheima.demo08.Synchronized.RunnableImpl@48140564
this:com.itheima.demo08.Synchronized.RunnableImpl@48140564
Thread-2-->正在卖第100张票
Thread-0-->正在卖第99张票
Thread-0-->正在卖第98张票
Thread-0-->正在卖第97张票
Thread-0-->正在卖第96张票
Thread-0-->正在卖第95张票
Thread-0-->正在卖第94张票

锁对象相同。

静态方法

package com.itheima.demo08.Synchronized;

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;
    //设置线程任务:卖票
    @Override
    public void run() {
        System.out.println("this:"+this);//this:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
        //使用死循环,让卖票操作重复执行
        while(true){
            payTicketStatic();
        }
    }
    /*
        静态的同步方法
        锁对象是谁?
        不能是this
        this是创建对象之后产生的,而静态方法优先于对象
        静态方法的锁对象是本类的class属性-->class文件对象(反射)
     */
    public static synchronized void payTicketStatic(){
        synchronized (RunnableImpl.class){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

静态的同步方法
锁对象是谁?
不能是this
this是创建对象之后产生的,而静态方法优先于对象
静态方法的锁对象是本类的class属性-->class文件对象(反射)

实现：

package com.itheima.demo08.Synchronized;

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        System.out.println("run:"+run);//run:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);   // 三个中的this是同一个对象 和上面创建的run也是同一个
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

执行结果：

run:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
this:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
this:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
this:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
Thread-0-->正在卖第100张票
Thread-0-->正在卖第99张票
Thread-0-->正在卖第98张票
Thread-0-->正在卖第97张票
Thread-0-->正在卖第96张票
Thread-0-->正在卖第95张票
Thread-0-->正在卖第94张票
Thread-0-->正在卖第93张票
Thread-0-->正在卖第92张票
Thread-0-->正在卖第91张票
Thread-0-->正在卖第90张票
Thread-0-->正在卖第89张票

Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。 Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock() :加同步锁。 public void unlock() :释放同步锁。

ock接口中的方法:
    void lock()获取锁。
    void unlock()释放锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口
使用步骤:
    1.在成员位置创建一个ReentrantLock对象
    2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
    3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
package com.itheima.demo09.Lock;

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

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //1.在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock(); //无论程序是否异常,都会把锁释放
                }
            }
        }
    }
}

实现：

package com.itheima.demo09.Lock;

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    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-1-->正在卖第100张票
Thread-1-->正在卖第99张票
Thread-1-->正在卖第98张票
Thread-1-->正在卖第97张票
Thread-1-->正在卖第96张票
Thread-1-->正在卖第95张票


 

Valentino112358
关注
多线程安全问题
XPmai的博客
12-22 841
在多线程编程中，线程安全问题是比较难，非常重要的问题。不管是在面试过程中还是在实际的工作中，也都是经常出错的地方。因此本篇文章着重介绍一下线程的安全问题。
浅谈 synchronized 锁机制原理 与 Lock 锁机制
m0_72885838的博客
08-23 1307
线程安全是并发编程中的重要关注点，造成线程安全问题的主要原因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。
多线程的安全问题
weixin_30381793的博客
11-22 662
1、多线程安全问题分析 　　多线程安全问题原因是在cpu执行多线程时，在执行的过程中可能随时切换到其他的线程上执行。 　　 　　在以上红色选中的三个部分，线程都有可能进行切换。只要cpu在这个三个地中的任何地方切换了，都可能导致错误数据出现，线程的不安全因素就有了。 　　造成错误数据的原因是多个线程可能出现同时访问num的情况。而任何一个线程在访问num的过程中都可以切换到其他的线程...
java的线程同步机制synchronized关键字的理解_.docx
10-09
Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
简单了解synchronized和lock的区别
08-25
了解synchronized和lock的区别 synchronized是Java语言...在Java中，synchronized和lock都是用于实现线程同步的机制，但它们有不同的实现机制和性能特点。在选择使用哪种机制时，需要考虑到具体的应用场景和性能要求。
Java编程synchronized与lock的区别【推荐】
08-29
synchronized 和 Lock 是 Java 编程中两种常用的同步机制，用于实现线程安全的访问。两者都可以实现同步访问，但是它们有着不同的设计理念和使用场景。 synchronized 的缺陷 synchronized 是 Java 语言内置的...
多线程---安全性问题
weixin_53999801的博客
06-26 224
线程安全是指：代码并行执行的结果和串行执行的结果完全一致，就称为该代码是线程安全的， 若多个线程串行执行的结果和并行执行的结果不同，这就称为线程不安全。创建两个子线程，分别开启，执行循环。我们预期的结果是count输出10000，但是实际结果明显不相符， 这就造成了并行执行的结果和单线程串行执行的结果不一致，显然这样的多线程是不安全的。 想要深入了解多线程的安全问题，首先需要了解JMM（JAVA Memory Model），也就是java的内存模型：描述多线程场景下java的线程内存（CPU的寄存器
Java多线程Lock与synchronized对比分析
在Java多线程编程中，Lock接口提供了比`synchronized`关键字更为灵活的锁机制。Lock接口定义在`java.util.concurrent.locks`包中，其核心功能是允许程序员更精确地控制线程的同步。在使用Lock时，需要注意的一个关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值