线程安全、死锁、通信

m0_70325973

已于 2024-07-09 20:26:39 修改

阅读量658

点赞数 24

文章标签： java 开发语言

于 2024-07-04 19:30:20 首次发布

本文链接：https://blog.csdn.net/m0_70325973/article/details/140187020

版权

程休眠方法--static void slep

public class SleepThread extends Thread{
    @Override
    public void run() {
        for (int i=0;i<20;i++){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"~~~~~~~"+i);
        }
    }
}

yield当前线程让出cpu参与下次的竞争

public class YieldTread extends Thread{
    @Override
    public void run() {
        for (int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"~~~~~~~"+i);
            Thread.yield();
            System.out.println("~~~~~^^^^~~~~~~");
        }
    }
}

join加入当前线程上

public class Test {
    public static void main(String[] args) throws InterruptedException {
        JoinThread test1=new JoinThread();
        JoinThread test2=new JoinThread();
        test1.setName("线程A");
        test2.setName("线程B");
        test1.start();
        test2.start();
        test1.join(); //t1加入主线程上，主线程需要等t1执行完毕后才会执行. 如果主线程需要等带t1和t2线程的执行结果 做下一步操作时。
        for (int i=0;i<10;i++){
            System.out.println("main----"+i);
        }
    }
}

setDaemon()设置线程为守护线程

public class Test {
    public static void main(String[] args) throws InterruptedException {
        DaemonTread daemon=new DaemonTread();
        daemon.setName("线程A");
        daemon.setDaemon(true);//设置t1为守护线程
        daemon.start();
        for (int i=0;i<20;i++){
            System.out.println("main----"+i);
        }
    }
}

解决线程安全问题

什么情况下会出现线程安全

当多个线程操作同一个资源时，则会出现线程安全问题。

Java如何解决线程安全问题

第一种：使用synchronized自动锁

使用synchronized 关键字

public class SellTicket implements Runnable{
    private int tick = 100;
    private static Object o = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (tick > 0) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    tick--;
                    System.out.println(Thread.currentThread().getName() + "卖了一张票；剩余:" + tick + "张");
                } else {
                    break;
                }
            }
        }
    }
}

第二种：使用lock手动锁

使用lock手动

public class SellTicket implements Runnable{
    private int tick = 100;

    private Lock l = new ReentrantLock();
//synchronized使用在方法那么它的共享锁为this
    @Override
    public void run() {
        while (true) {
            try {
                l.lock();//加锁
                if (tick > 0) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    tick--;
                    System.out.println(Thread.currentThread().getName() + "卖了一张票；剩余:" + tick + "张");
                } else {
                    break;
                }
            } finally {
                l.unlock();//解锁
            }
        }
    }
}

synchronized 和lock 区别

synchronized 可以使用代码块和方法，自动加锁和释放锁，不会出现死锁问题。

lock 只能使用在代码块中，需要手动添加和释放锁，如果不释放锁会出现死锁问题，他的释放锁必须放在finally中，使用灵活。

死锁

为什么会出现死锁？

当线程A拥有锁资源a但是需要锁资源b，而线程B拥有锁资源b而希望获取锁资源a。这时两个线程互相拥有对方所需要的锁资源，就会出现程序堵塞，从而造成死锁。

如何解决？

1.不使用锁嵌套

2.设置超时时间。--lock类中tryLock

3.使用安全java.util.concurrent下的类

线程通信

public class BankCard {
    private double balance;
    private boolean flag;//true:有钱  false:没钱
    public synchronized void cun(double money){
        if (flag==true){
            try {
                //wait属于object类中  进入等待队列 并且释放拥有的锁
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        //余额+
        balance+=money;
        //设置有钱标志
        flag=true;
        //唤醒等待序列中的某个缓存
        notify();
        System.out.println(Thread.currentThread().getName()+"往卡中存了:"+money+";卡中余额:"+balance);
    }

    public synchronized void qu(double money){
        if (flag==false){
            try {
                //wait属于object类中  进入等待队列 并且释放拥有的锁
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        //余额+
        balance-=money;
        //设置无钱标志
        flag=false;
        //唤醒等待序列中的某个缓存
        notify();
        System.out.println(Thread.currentThread().getName()+"往卡中取了:"+money+";卡中余额:"+balance);
    }

}

public class CunThread extends Thread{
    private BankCard bankCard;

    public CunThread(BankCard bankCard){
        this.bankCard=bankCard;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            bankCard.cun(1000);
        }
    }
}

public class QuThread extends Thread{
    private BankCard bankCard;

    public QuThread(BankCard bankCard){
        this.bankCard=bankCard;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            bankCard.qu(1000);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        BankCard bankCard=new BankCard();
        CunThread c=new CunThread(bankCard);
        c.setName("用户A");
        QuThread q=new QuThread(bankCard);
        q.setName("用户B");
        c.start();
        q.start();
    }
}