Java 多线程 —— 同步代码块（解决线程安全问题)

最新推荐文章于 2023-03-13 21:57:54 发布
最新推荐文章于 2023-03-13 21:57:54 发布
阅读量1.2w 收藏 231
点赞数 42
分类专栏： java 文章标签： java synchronized 多线程 同步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44823756/article/details/120925364
版权

目录

火车站抢票问题

由于现实中买票也不会是零延迟的，为了真实性加入了延迟机制，也就是线程休眠语句

package test.MyThread.ticketDemo;

public class RunnableThread implements Runnable{
    private int ticket = 100;
    @Override
    public void run(){
        while(true){
            if(ticket>0){
                try {
                    Thread.sleep(100);  //语句一
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName()+"正在出售第 "+ticket+" 张票");  //语句二
                ticket--;  //语句三
            }
        }
    }
}


package test.MyThread.ticketDemo;

public class ticketDemo1 {
    public static void main(String[] args) {
        RunnableThread r1 = new RunnableThread();

        Thread t1 = new Thread(r1,"窗口一");
        Thread t2 = new Thread(r1,"窗口二");
        Thread t3 = new Thread(r1,"窗口三");

        t1.start();
        t2.start();
        t3.start();

    }
}

在这里插入图片描述
但是结果和我们想象中的不一样，三个窗口卖出了同样的票

这是因为，CPU的操作具有原子性，单独执行一条指令或者说语句，在执行完毕前不会被中断。
三个线程被启动后，都会处于就绪状态，然后开始抢夺CPU执行语句。

  1. 语句一：Thread.sleep(100);
  2. 语句二： System.out.println(Thread.currentThread().getName()+“正在出售第 “+ticket+” 张票”);
  3. 语句三： ticket–;

我将程序中需要执行的三条主要语句列了出来
三条线程中，加入线程一先抢到了CPU，这时就会开始执行语句，也就是至少会完成一条语句一，然后进入休眠。

注：如果语句一不是休眠语句，而是别的语句，那么线程一就可以继续往下执行，因为原子性，正在执行的语句不会被打断，所以只会在一条语句结束，下一条语句未开始时，被抢走CPU或者中断，导致线程退出运行状态，转为就绪或者阻塞状态。所以线程一可以一次性完成多条语句，也有可能刚完成一条语句就被抢走了CPU。

接着，线程二，线程三也抢到了CPU，也开始执行语句一，然后也进入休眠状态。之后线程一二三从休眠中醒来，开始争抢CPU完成语句二，但是三者都在完成语句三之前被抢走了CPU，导致一直没有执行ticket–语句，ticket也就没有减少，因此三条线程一共打印三条输出语句，里面的ticket都是相同。

然后三条线程又开始争抢CPU来完成语句三，一个线程让ticket减一，三个线程减少三张票。完成语句三后，又开始新的循环，三个线程开始争抢CPU完成语句一。

因此，看到的结果会是，三条语句的ticket都相同，然后ticket突然减三，接着又输出三条ticket相同的输出语句。

那么，该如何解决这种情况呢？
这种延迟卖票的问题被称为线程安全问题，要发生线程安全问题需要满足三个条件（任何一共条件不满足都不会造成线程安全问题）：

  1. 是否存在多线程环境
  2. 是否存在共享数据/共享变量
  3. 是否有多条语句操作着共享数据/共享变量

火车站延迟卖票问题满足这三个条件，因此造成了线程安全问题，而前两条都不可避免，那么就可以着手于破坏掉第三个条件，让线程安全问题不成立。

思路是将多条语句包装成一个同步代码块，当某个线程执行这个同步代码块的时候，就跟原子性一样，其他的线程不能抢占CPU，只能等这个同步代码块执行完毕。

解决办法：

  1. synchronized —— 自动锁
  2. lock —— 手动锁

synchronized

synchronized(对象){  
	//可能会发生线程安全问题的代码
}
//这里的对象可以是任意对象，我们可以用 Object obj =  new Object()里面的obj放入括号中

使用synchronized的条件：

  1. 必须有两个或两个以上的线程
  2. 同一时间只有一个线程能够执行同步代码块
  3. 多个线程想要同步时，必须共用同一把锁
    synchronized(对象)括号里面的对象就是一把锁

使用synchronized的过程：

  1. 只有抢到锁的线程才可以执行同步代码块，其余的线程即使抢到了CPU执行权，也只能等待，等待锁的释放。
  2. 代码执行完毕或者程序抛出异常都会释放锁，然后还未执行同步代码块的线程争抢锁，谁抢到谁就能运行同步代码块。
同步代码块

因此，修改后的代码为：

package test.MyThread.ticketDemo;

public class RunnableThread implements Runnable{
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run(){
        while(true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "正在出售第 " + ticket + " 张票");
                    ticket--;
                }
            }
        }
    }
}


package test.MyThread.ticketDemo;

public class ticketDemo1 {
    public static void main(String[] args) {
    //这里没有改动，只是在上一个代码中加了一把锁
        RunnableThread r1 = new RunnableThread();

        Thread t1 = new Thread(r1,"窗口一");
        Thread t2 = new Thread(r1,"窗口二");
        Thread t3 = new Thread(r1,"窗口三");

        t1.start();
        t2.start();
        t3.start();

    }
}

在这里插入图片描述
可以看出来结果符合我们的预期，是正确的

现在又有了新的问题，那就是如果我在构造线程的RunnableThread类里面加入方法呢？同步代码块里面出现方法时，我们应该怎么“上锁”呢？

同步方法（this锁）
同步方法，在public的后面加上synchronized关键字
package test.MyThread.ticketDemo;

public class RunnableThread1 implements Runnable{
    private int ticket = 100;
    Object obj = new Object();
    public boolean flag = true;
    @Override
    public void run(){
        if(flag==true){
            while(ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                SellTicket1();
            }
        }
    }

//同步方法，在public的后面加上synchronized关键字
    public synchronized void SellTicket1(){
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+"正在出售第 "+ticket+" 张票");
            ticket--;
        }
    }
}

package test.MyThread.ticketDemo;

public class ticketDemo2 {
    public static void main(String[] args) throws InterruptedException {
        RunnableThread1 r = new RunnableThread1();

        Thread t1 = new Thread(r,"窗口一");
        Thread t2 = new Thread(r,"窗口二");

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

    }
}
this锁

先来看看，如果有两条路径，一条路径是使用同步代码块，但是对象是obj，另一条路径是使用同步方法

package test.MyThread.ticketDemo;

public class TicketWindow2 implements Runnable{
    //定义100张票
    private static int tickets = 100;
    Object obj = new Object();
    int i =0;
    @Override
    public void run() {
        while (true){
            if(i%2==0){
                synchronized (obj){
                    if(tickets>0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");

                    }
                }
            }else {
                sellTicket();
            }

            i++;
        }

    }
    
    public synchronized void sellTicket(){
            if(tickets>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");
            }
    }
}

在这里插入图片描述
结果出错，说明同步方法的用的对象锁不能是任意的对象，不同的线程应该用相同的锁。同步方法是属于对象，而在这个类里面调用方法的是this对象，也就是this.sellTicket()，因此把this提取出来作为对象锁中的对象。这样多个线程都用的是this锁

package test.MyThread.ticketDemo;

public class TicketWindow2 implements Runnable{
    //定义100张票
    private static int tickets = 100;
    Object obj = new Object();
    int i =0;

    @Override
    public void run() {
        while (true){
            if(i%2==0){
                synchronized (this){
                    if(tickets>0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");

                    }
                }
            }else {
                sellTicket();
            }

            i++;
        }

    }

    public synchronized void sellTicket(){
            if(tickets>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");
            }
    }
}

修改完成后再运行代码，发现没有错误

注：

  1. 一个线程使用同步方法，另一个线程使用同步代码块this锁，可以实现同步
  2. 一个线程使用同步方法，另一个线程使用同步代码块，但是不是this锁。这种情况不能实现同步。
静态同步方法

同步方法的锁对象是this，
静态同步方法的锁对象是：这个静态同步方法所属的类的字节码文件

下面代码挺长的，但其实就修改了上面同步方法的代码的两处地方

  1. public synchronized void sellTicket(){}改为
    public synchronized static void sellTicket(){}
  2. synchronized (this){}改为synchronized (TicketWindow2.class){}
package test.MyThread.ticketDemo;

public class TicketWindow2 implements Runnable{
    //定义100张票
    private static int tickets = 100;
    Object obj = new Object();
    int i =0;

    @Override
    public void run() {
        while (true){
            if(i%2==0){
                synchronized (TicketWindow2.class){
                    if(tickets>0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");

                    }
                }
            }else {
                sellTicket();
            }
            i++;
        }

    }

    public synchronized static void sellTicket(){
        if(tickets>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 张票");
        }
    }
}

main()方法里面创建进程和启动进程的代码，和上面同步方法里面的代码相同
结果也和上面的一样，都不再列出来了

死锁问题
package test.MyThread.ticketDemo;
//两个不同的锁对象
public class LockObject {
    public static final Object lock1 = new Object();
    public static final Object lock2 = new Object();
}


package test.MyThread.ticketDemo;

public class DieLockThread extends Thread{
    public boolean flag;

    public DieLockThread(boolean flag){
        this.flag = flag;
    }
    @Override
    public void run() {
        if(flag){
            synchronized(LockObject.lock1){
                System.out.println("lock1");
                synchronized(LockObject.lock2){
                    System.out.println("lock2");
                }
            }
        }else{
            synchronized(LockObject.lock2){
                System.out.println("lock2");
                synchronized(LockObject.lock1){
                    System.out.println("lock1");
                }
            }
        }

    }
}


package test.MyThread.ticketDemo;

public class DieLockDemo {
    public static void main(String[] args) {
        DieLockThread d1 = new DieLockThread(true);
        DieLockThread d2 = new DieLockThread(false);

        d1.start();
        d2.start();
    }
}

在这里插入图片描述
程序会卡在这一步，不能进行下一步也不能停止
利用有参构造，构造出来的线程d1应该是先获得锁对象LockObject.lock1然后执行打印语句。接着获取锁对象LockObject.lock2，然后打印lock2。
但是这里因为线程d2是先获取的锁对象LockObject.lock2，并占据这个锁对象，然后想获得锁对象LockObject.lock1，但LockObject.lock1此时被线程d1占据着

两个线程都在等待对方释放锁对象，然后进行下一步，但是两者都不释放，导致程序卡死在这里。这就造成了死锁。

lock

package test.MyThread.ticketDemo;

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

public class LockThread implements Runnable{
    private int ticket = 100;
    Lock lock = new ReentrantLock();
    @Override
    public void run(){
        while(ticket>0){
            try{
                lock.lock();
                if(ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 正在出售第 " + (ticket--) + " 张票");
                }
            }finally {
                lock.unlock();
            }
        }

    }
}


package test.MyThread.ticketDemo;

public class LockDemo {
    public static void main(String[] args) {
        LockThread lt = new LockThread();

        Thread t1 = new Thread(lt,"窗口一");
        Thread t2 = new Thread(lt,"窗口二");
        Thread t3 = new Thread(lt,"窗口三");

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

在这里插入图片描述
结果正确

一纸春秋
关注
  • 42
    点赞
  • 踩
  • 231
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
Java 多线程 —— 同步代码块（解决线程安全问题)，2024年最新网络安全面试必备的集合源码详解
2301_82243070的博客
04-15 1005
注：如果语句一不是休眠语句，而是别的语句，那么线程一就可以继续往下执行，因为原子性，正在执行的语句不会被打断，所以只会在一条语句结束，下一条语句未开始时，被抢走CPU或者中断，导致线程退出运行状态，转为就绪或者阻塞状态。之后线程一二三从休眠中醒来，开始争抢CPU完成语句二，但是三者都在完成语句三之前被抢走了CPU，导致一直没有执行ticket–语句，ticket也就没有减少，因此三条线程一共打印三条输出语句，里面的ticket都是相同。完成语句三后，又开始新的循环，三个线程开始争抢CPU完成语句一。
Java 多线程 —— 同步代码块，给大家安排上
m0_63174811的博客
10-31 240
必须有两个或两个以上的线程 同一时间只有一个线程能够执行同步代码块 多个线程想要同步时，必须共用同一把锁 synchronized(对象)括号里面的对象就是一把锁 使用synchronized的过程： 只有抢到锁的线程才可以执行同步 【一线大厂Java面试题解析+核心总结学习笔记+最新架构讲解视频+实战项目源码讲义】 浏览器打开：qq.cn.hn/FTf 免费领取 代码块，其余的线程即使抢到了CPU执行权，也只能等待，等待锁的释放。 代码执行完毕或者程序抛出异常都会释放锁，然后还未..
【收藏系列】多线程的代码案例（单例模式 + 阻塞队列 + 定时器 + 线程池）
LYJbao的博客
09-28 536
重点收藏喔
【Java多线程】同步代码块处理线程安全问题
qq_64976935的博客
02-04 765
假如你在上厕所，另一个人很急，冲进了你所在的厕所。这就出现了安全问题。我们可以看到还是有重票的。因为上文有描述到的。题：创建三个窗口卖票，总票数为100张。根据多次运行也并未发现错票跟重票。我们首先模仿上面的方法，运行测试；
wait()和sleep()；休眠了以后别的线程能拿到锁吗
m0_73402102的博客
03-13 174
对于wait()和sleep()方法，学过多线程的都不会陌生，这两个方法的作用都是使线程休眠，暂时停止工作，不过这两个方法对于锁的使用情况大不相同，下面我详细说明一下。
线程安全问题之线程同步机制（同步代码块）
一点一滴
08-06 1573
继续讨论多窗口卖票问题中的线程安全问题： 方式二： 一、问题： 出现了线程安全问题 ? 二、问题的原因： 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。 三、出现线程安全问题的根本原因： 1、存在两个或者两个以上的线程对象，而且线程之间共享着一个资源。 2、有多个语句操作了共享资源。
线程状态、线程调度、线程安全、多线程、同步方法、同步代码块
贫民窟代言人的博客
08-19 110
将线程要操作的代码放入同步方法中，当线程执行到同步方法的时候，一定会执行完同步方法里所有代码后在释放cpu资源，从而一个线程对数据的操作不会受其他线程的影响。在一个线程中操作共享数据的时候，还没有操作完毕，线程失去了CPU资源，CPU资源被另外一个线程获取，另外一个线程会接着上一个线程操作数据继续执行操作，当另一个线程操作数据完毕之后，第一个线程又获取了CPU资源，此时，第一个线程看到的数据时第二个线程操作后的数据，由此就会引发数据不安全问题。syncObject为同步的对象，通常this。
Java多线程——线程八锁案例分析.docx
06-21
在Java多线程编程中，线程安全是一个关键概念，特别是在并发访问共享资源时。"线程八锁案例分析"文档中的示例着重展示了`synchronized`关键字如何在控制线程同步方面发挥作用。以下是对这些案例的详细分析： 案例1...
Java 多线程synchronized关键字详解(六)
09-03
除了同步方法，还可以使用`synchronized`关键字来创建同步代码块，指定要锁定的对象。同步块更加灵活，可以针对特定的资源加锁，而不是整个对象。同步块的语法如下： ```java synchronized (object) { // 需要...
Java学习源码Java多线程的代码
最新发布
06-15
在char01包里放置Java多线程基本知识的代码。内容如下： 如何使用多线程 如何得到多线程的一些信息 如何停止线程 如何暂停线程 线程的一些其他用法 在char02包里放置了Java对变量和对象并发访问的知识的代码...
JAVA多线程同步机制及其应用.doc
06-10
总的来说，Java多线程同步机制及其应用是Java编程中复杂而重要的主题，理解和熟练掌握这些机制对于开发高效、安全的多线程应用程序至关重要。通过深入学习和实践，开发者可以更好地处理并发场景下的各种挑战。
JAVA多线程学习笔记整理（csdn）————程序.pdf
12-01
- **同步代码块**：使用synchronized关键字锁定一个对象，确保同一时间只有一个线程可以执行同步代码块。 - **同步方法**：在方法前使用synchronized关键字，对整个方法进行加锁。 - **Lock对象**：ReentrantLock...
题目：同步代码块的死锁问题
qq_42449963的博客
05-20 525
死锁代码： public class Test { public static void main(String[] args) { final StringBuffer s1 = new StringBuffer(); final StringBuffer s2 = new StringBuffer(); new Thread(){ ...
java线程安全之synchronized代码块（六）
hfbin的博客
11-16 979
java线程安全之synchronized代码块（六）
Java多线程（ Thread & Runnable）& Java同步代码块、同步方法、Lock锁
weixin_43294854的博客
06-14 375
实现多线程方式一:(继承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
多线程之代码块同步方式
z2014ypd的博客
03-04 209
1.同步代码块 语法结构： synchronized（同步监听对象）{ 需要被同步的代码（有线程安全问题的代码） ｝ 语法特点： ① 必须保证多个线程访问到的是同一个同步监听对象；使用static修饰 ② 若是接口实现方法，则使用this同步监听 ③ 若是继承的方法，则使用类的字节码对象 例如 String.class。 一个类的字节码对象永远只有一份，不管通过何种方式加载的，相当于是单例的 2....
JavaSE之多线程、线程安全问题和synchronized代码块
weixin_47543906的博客
11-09 234
在多线程环境下，多个线程会抢占同步代码块中的锁对象。当一个线程获取锁，就可以成功进入同步代码块，其他线程获取不到锁，需要在同步代码块外面等待（阻塞）。 获得锁的线程执行完同步代码块后会释放锁，此时所有等待的线程会重新争夺锁对象（释放锁的线程也会再次参与争夺）。 抢到锁的线程就可以进行同步代码块执行。
同步代码块解决线程安全问题[java]
m0_57001006的博客
11-20 156
同步代码块解决继承Thread类的方式的线程安全问题 使用同步代码块处理继承Thread类的线程安全问题时,我们为了所有的线程都使用同一个同步监视器(锁),这就要求我们在继承Thread的类的子类中创建同步监视器的时候,也就是创建某个类的对象的时候使用static关键字修饰这个对象(锁),这样就可以保证所有的线程是使用的同一把锁,也就能确保线程的安全执行了 class Window1 extends Thread{ private static int ticket=100; static
Java线程安全与线程同步（同步代码块、同步方法、锁机制）
sc179的博客
10-08 392
目录1 线程安全1.1 概念1.2 程序演示2 线程同步2.1 同步代码块2.2 同步方法2.3 锁机制 1 线程安全 1.1 概念 多个线程同时运行一段代码，每次运行结果和单线程运行结果一样，且其他变量值也和预期一样，就称为线程安全。 1.2 程序演示 我们通过模拟电影院卖票来感受下线程的安全问题： 票及卖票过程：Runnable接口的子类； 卖票窗口：线程对象。 public class Ticket implements Runnable { private int ticket = 10
java多线程如何解决线程安全问题
05-26
Java多线程中，线程安全问题是一个常见的问题，因为多个线程可能同时访问共享的资源。为了解决线程安全问题，可以采用以下几种方法： 1. 同步代码块：使用synchronized关键字来保证同一时间只有一个线程可以进入同步代码块，从而避免并发访问共享资源。 2. 同步方法：使用synchronized关键字修饰方法，确保同一时间只有一个线程可以执行该方法，从而避免并发访问共享资源。 3. Lock锁：使用java.util.concurrent.locks.Lock接口来实现同步，它提供了更灵活的锁定方式，可以手动加锁和解锁，可以实现公平锁和非公平锁等。 4. 原子变量：使用java.util.concurrent.atomic包中的原子变量，例如AtomicInteger、AtomicBoolean等，来保证操作的原子性，避免并发访问共享资源时出现问题。 5. volatile关键字：使用volatile关键字来修饰共享变量，确保多线程之间的可见性，避免出现线程之间的数据不一致问题。 需要根据具体的应用场景来选择合适的线程安全解决方案。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一纸春秋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值