Java 线程安全

骑猪看日落 2024-03-24 10:54 50阅读 0赞

## 一、什么是线程安全 ##

当多个线程访问共享资源时，每个线程都会各自对共享资源进程操作，导致数据不一致，造成程序不能正确的得到结果，此时需要让多个线程排队访问共享资源，让线程安全，才能保证数据安全的被访问。

## 二、实现线程安全 ##

让线程同步(线程排队访问共享资源)，保证线程安全，其中的细节都在注释里。

（1）使用synchronized关键字，把共享资源上锁，让每个线程访问之前排队。

1.同步方法

案例为：模拟买票

package com.synchronizeddd;
    
    public class Ticket01 implements Runnable {
        // 总票数
        private int count = 100;
        // 购买票数
        private int nums = 0;
    
    
        // 重写run()方法
        @Override
        public void run() {
            while (true) {
    
                // 为了只让黄牛抢一张票 抢到返回true 
                // 执行return结束run()方法 也就结束了黄牛线程
                if (rob())
                    return;
    
            }
        }
    
        // 同步方法
        private synchronized boolean rob() {
    
            if (count > 0) {
                count--;
                nums++;
                if (Thread.currentThread().getName().equals("黄牛党")) {
                    System.out.println(Thread.currentThread().getName() + "抢了第" + nums + "张票，还剩" + count + "张。");
                    // 为了结束黄牛线程
                    return true;
                }
                System.out.println(Thread.currentThread().getName() + "抢了第" + nums + "张票，还剩" + count + "张。");
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
    
            }
    
            return false;
        }
    }

测试类：

package com.synchronizeddd;
    
    public class Test01 {
        public static void main(String[] args) {
            // 创建线程任务 
            Ticket01 ticket = new Ticket01();
    
            // 创建线程
            Thread threadHN = new Thread(ticket, "黄牛党");
            Thread thread1 = new Thread(ticket, "小白");
            Thread thread2 = new Thread(ticket, "Ikun");
    
            // 线程就绪
            threadHN.start();
            thread1.start();
            thread2.start();
    
        }
    }

运行结果：

![77a93d6ee6c544d5a49b3aea93bcb746.png][]

2.同步代码块

案例与上相同

package com.synchronizeddd;
    
    public class Ticket implements Runnable {
        // 总票数
        private int count = 100;
        // 购买票数
        private int nums = 0;
    
    
        // 重写run()方法 
        @Override
        public void run() {
            while (true) {
                /* 保证线程安全 使用synchronized 实现同步代码块
                 synchronized(obj){} obj为一个锁对象  锁对象要唯一  
                 保证每个线程都是用同一个锁 若多个锁不能保证同步
                 this在对象中指向自己 在此处指向线程任务对象
                 在测试类创建线程时 每个线程的线程任务对象都是同一个 故满足锁对象唯一 可参考测试类
                 */
                synchronized (this) {
                    if (count > 0) {
                        count--;
                        nums++;
                        if (Thread.currentThread().getName().equals("黄牛党")){
                            System.out.println(Thread.currentThread().getName() + "抢了第" + nums + "张票，还剩" + count + "张。");
                            // 结束run()方法 即黄牛的线程
                            return;
                        }
                        System.out.println(Thread.currentThread().getName() + "抢了第" + nums + "张票，还剩" + count + "张。");
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
    
                    }
                }
    
            }
        }
    }

测试类：

package com.synchronizeddd;
    
    public class Test {
        public static void main(String[] args) {
            // 创建线程任务 下面创建的线程都是使用此线程任务 保证锁对象唯一
            Ticket ticket = new Ticket();
            
            // 创建线程
            Thread threadHN = new Thread(ticket, "黄牛党");
            Thread thread1 = new Thread(ticket, "小白");
            Thread thread2 = new Thread(ticket, "Ikun");
    
            // 线程就绪
            threadHN.start();
            thread1.start();
            thread2.start();
    
        }
    }

运行结果：

![9b5ae6c4652044689df048da4d270fca.png][]

（2）使用Lock锁

案例同上

package com.lock;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class MyLock01 implements Runnable {
        // 总票数
        private int count = 100;
        // 购买票数
        private int nums = 0;
    
        //使用静态引用 确保锁对象唯一
        static Lock lock = new ReentrantLock();
    
        // 重写run()方法
        @Override
        public void run() {
            while (true) {
                // 调用lock()方法  进行上锁  
                // 让若把锁放在循环外 则开不了锁 因为死循环没结束
                lock.lock();
    
                if (count > 0) {
                    // 修改票数
                    count--;
                    nums++;
    
                    // 黄牛党只能给一张票 不能让他们太嚣张
                    if (Thread.currentThread().getName().equals("黄牛党")) {
                        System.out.println(Thread.currentThread().getName() + "抢了第" + nums + "张票，还剩" + count + "张。");
                        // 结束run()方法 即黄牛的线程
                        // 但注意 return结束方法后 并没有开锁 会造成死锁
                        // 结束之前需要开锁
                        lock.unlock();
                        return;
                    }
    
                    // 普通人
                    System.out.println(Thread.currentThread().getName() + "抢了第" + nums + "张票，还剩" + count + "张。");
    
                    //模拟网络延迟
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
    
                // 开锁 当一个线程访问结束后 一个开锁让其他线程进来访问
                lock.unlock();
    
            }
    
        }
    }

测试类：

package com.lock;
    
    import com.synchronizeddd.Ticket;
    
    public class Test01 {
        public static void main(String[] args) {
            // 创建线程任务
            MyLock01 ticket = new MyLock01();
    
            // 创建线程
            Thread threadHN = new Thread(ticket, "黄牛党");
            Thread thread1 = new Thread(ticket, "小白");
            Thread thread2 = new Thread(ticket, "Ikun");
    
            // 线程就绪
            threadHN.start();
            thread1.start();
            thread2.start();
    
        }
    }

运行结果：

![5d74b774d6a14c6dbb505563cacf6270.png][]

[77a93d6ee6c544d5a49b3aea93bcb746.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/725e8e0ff66e4c27b39651797734489b.png
[9b5ae6c4652044689df048da4d270fca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/82a35ad1e9e644848d5dec3dfe4f9077.png
[5d74b774d6a14c6dbb505563cacf6270.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/bf929238343f4d2b8cf48d86b979d21a.png