线程安全三部曲

最新推荐文章于 2025-12-30 20:41:53 发布

原创最新推荐文章于 2025-12-30 20:41:53 发布 · 175 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #多线程 #并发编程 #编程语言

本文详细介绍了Java中实现线程安全的三种方式：同步代码块、同步方法和显式锁（ReentrantLock）。通过示例代码展示了如何使用这些机制确保多线程环境下的数据一致性，强调了隐式锁与显示锁在使用上的区别和注意事项。

线程安全

线程的玩法
在这里插入图片描述

同步代码块(隐式锁)

我在线程的玩法文章中讲述了线程可能出现不安全的问题,针对前面的问题我提供了一篇解决方案.

上锁

给线程上锁,使用锁进行安全性操作.速成回收掏操作,三个线程开一把锁.进行线程操作.让if的代码块进行排队执行.

package work.february.five;

import work.february.three.Demo8;

/**
 * @Author: 小浪
 * @Description:
 * @Date Created in 2021-02-05 14:01
 * @Modified By:
 */
public class Demo {
    public static void main(String[] args) {
        //设置线程锁
        Runnable runnable=new Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();


    }
        static class Ticket implements Runnable{
           private int count =10;
           private Object object =new Object();
            @Override
            public void run() {

                while (true) {
                    synchronized (object){
                    if (count > 0) {

                        System.out.println(Thread.currentThread().getName()+"正在准备取票:");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println("出票成功,余票:" + count);
                    }
                }
            }
        }
    }
}

在这里插入图片描述

同步方法

方法上锁

package work.february.five;

/**
 * @Author: 小浪
 * @Description:
 * @Date Created in 2021-02-05 14:38
 * @Modified By:
 */
public class Demo1 {
    public static void main(String[] args) {
        //设置线程锁
        Runnable runnable=new Demo.Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();


    }
    static class Ticket implements Runnable{
        private int count =10;

        @Override
        public void run() {

            while (true) {
                boolean flag =sale();
                if(!flag){
                    break;
                }

            }
        }
        public synchronized boolean sale(){
            if (count > 0) {
                System.out.println(Thread.currentThread().getName()+"正在准备取票:");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功,余票:" + count);
                return true;
            }
            return false;
        }
    }

}

显示锁

package work.february.five;

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

/**
 * @Author: 小浪
 * @Description:
 * @Date Created in 2021-02-05 15:01
 * @Modified By:
 */
public class Demo2 {
    public static void main(String[] args) {
        //设置线程锁
        Runnable runnable=new Demo.Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();


    }
    static class Ticket implements Runnable{
        private int count =10;
        private  Lock  l=new ReentrantLock();
        @Override
        public void run() {

            while (true) {
                //显式锁
                    l.lock();
                    if (count > 0) {
                        System.out.println(Thread.currentThread().getName()+"正在准备取票:");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println("出票成功,余票:" + count);
                    }
                    l.unlock();
                }

        }
    }
}

显式锁与隐式锁的区别

Sync 和 Lock 的出身（原始的构成）不同：

Sync：Java中的关键字，是由JVM来维护的。是JVM层面的锁。 Lock：是JDK5以后才出现的具体的类。使用 Lock是调用对应的API。是API层面的锁。 Sync 底层是通过 monitorenter 进行加锁（底层是通过 monitor对象来完成的，其中的wait/notify等方法也是依赖于 monitor对象的。只有在同步代码块或者同步方法中才可以调用wait/notify等方法。因为只有在同步代码块或者是同步方法中，JVM才会调monitory 对象）；通过 monitorexit 来退出锁。而 Lock 是通过调用对应的API方法来获取锁和释放锁。

使用方法不同

Sync是隐式锁；Lock是显示锁。

所谓的显示和隐式就是在使用的时候，使用者要不要手动写代码去获取锁和释放锁。

在使用sync关键字的时候，程序能够自动获取锁和释放锁。那是因为当sync代码块执行完成之后，系统会自动的让程序释放占用的锁。Sync是由系统维护的，如果非逻辑问题的话，是不会出现死锁的。
在使用lock的时候，我们使用者需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。手动获取锁方法：lock()；释放锁：unlock()。
在这里插入图片描述