一星期全栈速成-----线程安全问题以及解决方案

最新推荐文章于 2024-07-29 14:22:26 发布

又捡了一块钱

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量1k

点赞数 35

文章标签： java 前端开发语言

本文链接：https://blog.csdn.net/qq_59048453/article/details/134668487

版权

线程安全问题

买票问题：

package myRunable_1;

public class MyRunnable implements Runnable{
    private int num = 100;

    @Override
    public void run() {
        while (true){

     System.out.println(Thread.currentThread().getName()+": 卖出第:" +num--+"张票");
                
            }
        }

    }
}

测试类

public class MyTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable,"窗口一：");
        Thread thread2 = new Thread(myRunnable,"窗口二：");
        Thread thread3 = new Thread(myRunnable,"窗口三：");
//好处，可以实现多个接口
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

发现问题：同票问题

问题2：卖出不存在的票

原因：

出现同票原因

// 线程抢夺cpu 执行权时，执行的代码具有原子性
// 原子性是指最基本的代码（最小的语句）

出现负票的原因

线程的运行是抢占式的，出现负票首先是，线程1，2，3都在等于1的时候进去了while循环，导致多次输出

解决


public class My_Thread_Optimal extends Thread{
    private static int ticket = 100;

    private String str = "";

    public My_Thread_Optimal(String name) {
        super(name);
    }

    @Override
    public void run() {
        try {
            //睡眠100毫秒
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //只允许一个程序同步，解决重复票的问题
        synchronized (str){
        while (ticket>0){
            
                //解决最后卖出不存在票的问题
                if (ticket==0){
                    break;
                }
                System.out.println(getName()+": 卖出第:" +ticket+"张票");
                ticket--;
            }
        }

    }
}

锁

同步锁：

当线程出现不安全情况，我们就可以用同步锁来将其锁住，只让一个线程去使用公共的资源。

synchronized ( obj ){}

参数可以是任意的对象，他的作用就是提供一个钥匙，谁有钥匙就可以打开锁。这样就解决了卖出同票的问题。

将输出的语句

和数据改变的语句分开，在判断是否有不存在的票。解决负票的问题。

Lock锁：

public void run() {
        while (true){
            lock.lock(); //上锁
            if(ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+"第"+ticket+"张票");
                ticket--;// 0
            }
            lock.unlock(); //释放锁
        }
    }

lock锁使用灵活，不需要参数。

synchronized与lock的区别

synchronized jvm级别的锁,jvm自动上锁和解锁

Lock锁java代码写的锁，需要手动的加锁和释放锁

死锁

多线程产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用。

保持和请求条件：一个进程因请求资源而阻塞时，对已获得资源保持不放。

不可剥夺调用：进程已获得资源，在未使用完成前，不能被剥夺。

循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

线程的生命周期图

新建：创建线程对象

就绪：有执行资格，但是没有拿到执行权

运行：有执行资格，且有执行权

阻塞：没有执行资格，没有执行权; 恢复阻塞回到就绪状态

死亡：线程变成垃圾，等待回收

线程间的通信

正常思路：

生产者：

先看有没有数据，有就等待，没有就生产，生产后，通过消费者来消费数据

消费者：

先看有没有数据，有就消费，没有就等待，且通知生产都生产数据

为了实现上述的问题，Java提供一种机制，等待唤醒机制

案例：

取钱案例

分析：

Account对象（money）

SetMoney对象（生产者）

GetMoney对象（消费者）

Test(测试类)

Account：


public class Account {
    private int money;
   

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

SetMoney：


import java.util.Scanner;

public class SetMoney implements Runnable{
    Account a = new Account();

    public SetMoney(Account a) {
        this.a = a;
    }

    public SetMoney() {
    }

    @Override
    public void run() {

            while (true){
                synchronized (a){
                    if (a.getMoney()>0){//有钱，不设置
                        try {
                            a.wait();//等待
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //没钱，设置钱
                    int money=0;
                    Scanner scanner = new Scanner(System.in);

                    System.out.println("请输入要存多少钱：");
                    money=scanner.nextInt();
                    if (a.getMoney()<=0){
                        a.notify();
                        a.setMoney(money);
                        System.out.println(Thread.currentThread().getName() + "存入" + a.getMoney());

                    }

                    a.notify();


                }
            }




    }
}

GetMoney：


import java.util.Scanner;

public class GetMoney implements Runnable{
    private Account a = new Account();

    public GetMoney(Account a) {
        this.a = a;
    }

    public GetMoney() {
    }

    @Override
    public void run() {

//            Scanner scanner = new Scanner(System.in);
//            int getMoney = scanner.nextInt();
//            System.out.println("请输入要取多少：");

            while (true) {
                synchronized (a) {
                if(a.getMoney()<=0){//没钱，等待
                    try {
                        a.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }


                if ((a.getMoney() - 100 < 0)) {
                    System.out.println("余额不足，请管理先存入");
                    a.notify();
                    break;
                }

                    System.out.println(Thread.currentThread().getName() + "取走：" + a.getMoney()+ "元！");


                    a.setMoney(a.getMoney() - 100);
                    System.out.println("剩余:" + a.getMoney() + "元");

                    a.notify();//唤醒线程
                } //运行到这里,证明原来有钱，flag是true，下面取走，要变false；

            }







    }
}

Test：


public class Test {
    public static void main(String[] args) {

        Account a = new Account();

        SetMoney setMoney = new SetMoney(a);

        GetMoney getMoney = new GetMoney(a);
        //设置钱
        Thread setThread = new Thread(setMoney,"管理");
        //取钱
        Thread getThread1 = new Thread(getMoney,"张三");
        Thread getThread2 = new Thread(getMoney,"李四");
        Thread getThread3 = new Thread(getMoney,"王五");


        setThread.start();

        getThread1.start();
        getThread2.start();
        getThread3.start();
    }
}