其他分享
首页 > 其他分享> > Day29.线程安全、线程同步synchronized() 、死锁

Day29.线程安全、线程同步synchronized() 、死锁

作者：互联网

线程安全(重点)

条件1:多线程并发； 条件2:有共享数据； 条件3:有共享修改的行为；

线程同步机制：线程排队执行(不能并发)，用排队机制解决线程安全难问题。

线程同步机制会牺牲一部分效率，数据安全第一位。

        异步  |  同步

  • 异步编程模型:
    线程t1和线程t2，各自执行各自的。t1不管t2，t2不管t1，谁也不需要等谁。

  • 同步编程模型:
    线程t1和线程t2，两个线程之间发生了等待关系，排队执行，效率较低。

  • 异步就是并发，同步就是排队

 模拟银行账户取款

/*银行账户 不使用线程同步机制，多线程对同一个账户取款，出现线程安全问题*/
public class Account {
    private String actno;   //账号
    private double balance;  //余额
    //构造方法.getset省略

    //取款的方法
    public void withdraw (double money){
        double before = this.balance;     //t2执行到此处，余额未更新，数值还是1w，就会出问题
        //取款那之后的余额
        double after = before - money;
        //模拟网络延迟
        try { 
            Thread.sleep(1000);           //t1执行到此处
        } catch (InterruptedException e) {
            e.printStackTrace(); }
        //更新余额
        this.setBalance(after);
        //打印信息
        System.out.println(Thread.currentThread().getName()+"对账户"+this.getActno()+"取款成功，余额:"+this.getBalance());
    }
}
public class AccountThread extends Thread{
    //两个线程必须共享同一个账户对象
    private Account act;
    //通过构造方法传递过来账户对象
    public AccountThread(Account act){
        this.act = act;
    }
    public void run(){
        //run方法执行表示取款操作
        double money = 5000; //取款5000
        //取款
        act.withdraw(money);
    }
}
public class Test {
    public static void main(String[] args) {
        //创建账户对象
        Account act = new Account("act-001",10000);
        //创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
        //设置name
        t1.setName("t1");
        t2.setName("t2");
        //启动线程取款
        t1.start();
        t2.start();
    }
}

同步代码块synchronized() 

synchronized(){
    //线程同步代码块
}

synchronized()内传入的"数据"是相当关键的。
这个数据必须是多线程共享的数据，才能达到线程排队。
()中写什么，要看需要让哪些线程同步。
假设t1,t2,t3,t4,t5五个线程
只希望t1,t2,t3排队，t4,t5不排队
一定要在()中写一个t1,t2,t3共享，t4,t5不共享的对象。

    //取款的方法
    public void withdraw (double money){
        //以下这几行代码必须是线程排队的，不能并发

        //这里的账户是共享的，那么this就是账户对象
        synchronized (this){
            double before = this.balance;
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace(); }
            this.setBalance(after);
            System.out.println(Thread.currentThread().getName()+"对账户"+this.getActno()+"取款成功，余额:"+this.getBalance());
        }
    }

 理解：当t1线程执行到 synchronized(o) 会占用o对象的对象锁，而t2线程执行到此处时，这个对象锁已经被占用，所以只能等待t1执行完成后归还对象锁，才能继续执行。反之同理。

在java语言中，任何对象都有一把“锁”。

  • 哪些变量存在线程安全问题？
  • java中有三大变量 ：实例变量：在堆中；局部变量：在栈中；静态变量: 在方法区中
  • 局部变量永远都不存在线程安全问题，因为局部变量不共享(一个线程一个栈)
  • 局部变量在堆中，堆只有一个，可能存在线程安全问题
  • 静态变量在方法区中，方法区只有一个，可能存在线程安全问题
    //取款的方法
    public synchronized void withdraw (double money){
        ....
    }

死锁

当synchronized使用不当，可能会出现死锁(deadlock)。

不会出现错误，也不会出现异常。这种错误最难调试

synchronized最好不要嵌套使用，一不小心就会导致死锁现象的发生。

/*
死锁代码要会写，一般面试官要求会写
只有会写，才会在以后开发中注意
 */
public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        //t1,t2两个线程共享o1,o2
        MyThreadx t1 = new MyThreadx(o1,o2);
        MyThready t2 = new MyThready(o1,o2);
        t1.start();
        t2.start();

    }
}
class MyThreadx extends Thread{
    Object o1;
    Object o2;
    public MyThreadx(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    public void run(){
        synchronized (o1){
            try {
                Thread.sleep(1000);    //等待t2锁死
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){
                System.out.println("t1执行成功");
            }
        }
    }
}
class MyThready extends Thread{
    Object o1;
    Object o2;
    public MyThready(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    public void run(){
        synchronized (o2){
            try {
                Thread.sleep(1000);    //等待t1锁死
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){
                System.out.println("t2执行成功");
            }
        }
    }
}

注:

ArrayList是非线程安全的、Vector是线程安全的

HashSet、HashMap是非线程安全的、Hashtable是线程安全的

StringBuffer安全、StringBuildre不安全

标签：Day29,synchronized,t2,t1,死锁,线程,public,o1
来源： https://blog.csdn.net/a111042555/article/details/122500707