线程安全问题的详细示例

本文深入探讨了线程安全问题,通过具体示例揭示了由于范围不当导致的性能降低和线程不安全现象。强调了同步块的重要性,并指出锁的对象选择对于确保数据完整性至关重要。建议锁定合适的数据范围,以实现更有效的线程安全控制。
摘要由CSDN通过智能技术生成

线程安全问题的详细示例

范围太大 性能低下
同步块 锁对象 这个对象是this 与锁test2()这个方法一样

线程不安全 ticketNum对象在变 ,锁的对象不能变

线程不安全 范围太小锁不住

尽可能锁定合理的范围(不是指代码,而是指数据的完整性)

package cn.com.state;

public class TestSafe implements Runnable{
    private int ticketNum = 10;
    private boolean flag = true;
    @Override
    public void run() {
        while(flag) {
            //Thread.yield();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //test1();
            //test2();
            //test3();
            //test4();
            test5();
        }
    }
    //线程安全 同步 成员的方法锁的是this 即这个对象
    public synchronized void test1() {
        if (ticketNum <= 0) {
            this.flag = false;
            return;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"-->"+ticketNum--);
    }
    public void test2() {
        //范围太大 性能低下
        //同步块  锁对象 这个对象是this 与锁test2()这个方法一样
        synchronized(this) {
            if (ticketNum <= 0) {
                this.flag = false;
                return;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + ticketNum--);
        }
    }
    public void test3() {
        //线程不安全 ticketNum对象在变
        synchronized((Integer)ticketNum) {
            if (ticketNum <= 0) {
                this.flag = false;
                return;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + ticketNum--);
        }
    }
    public void test4() {
        //线程不安全 范围太小锁不住
        synchronized(this) {
            if (ticketNum <= 0) {
                this.flag = false;
                return;
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"-->"+ticketNum--);
    }
    public void test5() {
        //提高了性能 double checking 双重检测
        //尽可能锁定合理的范围(不是指代码,而是指数据的完整性)
        if (ticketNum <= 0) { //考虑的是没有票的情况
            this.flag = false;
            return;
        }
        synchronized (this) {
            if (ticketNum <= 0) { //考虑的是最后一张票的情况下
                this.flag = false;
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + ticketNum--);
        }
    }
    public static void main(String[] args) {
        TestSafe ts = new TestSafe();
        new Thread(ts,"小明").start();
        new Thread(ts,"小红").start();
        new Thread(ts,"小亮").start();
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程下可能会出现线程安全问题,比如多个线程同时访问同一个共享资源,可能会导致数据不一致或者程序崩溃等问题。常用的解决方法有以下几种: 1. 互斥锁(mutex):使用互斥锁可以保证同一时间只有一个线程能够访问共享资源,其他线程需要等待互斥锁的释放。可以使用 C++11 中的 std::mutex 来实现互斥锁。 2. 读写锁(read-write lock):如果共享资源被频繁地读取而很少修改,可以使用读写锁来提高程序的性能。读写锁允许多个线程同时读取共享资源,但只能有一个线程写入共享资源。可以使用 C++11 中的 std::shared_mutex 来实现读写锁。 3. 原子操作(atomic operation):在多线程环境下,如果有多个线程同时修改同一个变量,可能会导致数据不一致的问题。可以使用原子操作来保证变量的原子性,即同一时间只有一个线程能够修改变量。可以使用 C++11 中的 std::atomic 来实现原子操作。 4. 条件变量(condition variable):当一个线程需要等待某个条件满足时,可以使用条件变量来阻塞线程并等待条件变量的通知。可以使用 C++11 中的 std::condition_variable 来实现条件变量。 示例代码如下: ``` #include <iostream> #include <thread> #include <mutex> std::mutex mtx; void print(int id) { mtx.lock(); // 上锁 std::cout << "Thread " << id << " is printing." << std::endl; mtx.unlock(); // 解锁 } int main() { std::thread t1(print, 1); std::thread t2(print, 2); t1.join(); t2.join(); return 0; } ``` 上述代码中,两个线程都会执行 print 函数,但由于使用了互斥锁 mtx,同一时间只有一个线程能够访问 std::cout。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值