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

线程安全(重点)

  • 什么时候数据会存在线程安全问题?

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

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

  •  如何解决线程安全问题?

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

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

        异步  |  同步

  • 异步编程模型:
    线程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();
    }
}

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

同步代码块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());
        }
    }

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

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

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

  • 哪些变量存在线程安全问题?
  • java中有三大变量 :实例变量:在堆中;局部变量:在栈中;静态变量: 在方法区中
  • 局部变量永远都不存在线程安全问题,因为局部变量不共享(一个线程一个栈)
  • 局部变量在堆中,堆只有一个,可能存在线程安全问题
  • 静态变量在方法区中,方法区只有一个,可能存在线程安全问题
  • 在实例方法上使用synchronized修饰,锁的是this
  • 缺点:1.不灵活
               2.整个方法体都需要同步,可能会无故扩大同步范围,导致程序执行效率降低
  • 在静态方法上使用synchronized,锁的是类
    //取款的方法
    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不安全

上一篇:Java 发展史


下一篇:Java8 Optioanl解决空指针异常