Day29-30.线程安全、线程同步synchronized() 、死锁线程安全(重点)

90 阅读 0 评论 60 点赞

我是靠谱客的博主忧伤龙猫，最近开发中收集的这篇文章主要介绍Day29-30.线程安全、线程同步synchronized() 、死锁线程安全(重点)，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

线程安全(重点)

同步代码块synchronized()

死锁

Lock锁

线程安全(重点)

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

条件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中有三大变量：实例变量：在堆中；局部变量：在栈中；静态变量: 在方法区中
局部变量永远都不存在线程安全问题，因为局部变量不共享(一个线程一个栈)
局部变量在堆中，堆只有一个，可能存在线程安全问题
静态变量在方法区中，方法区只有一个，可能存在线程安全问题

在实例方法上使用synchronized修饰，锁的是this
缺点：1.不灵活
2.整个方法体都需要同步，可能会无故扩大同步范围，导致程序执行效率降低

private synchronized void extracted() {    //买票方法
    if(num>0){
        System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票");
    }
}

在静态方法上使用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执行成功");
            }
        }
    }
}

面试题：sleep()和wait()方法的区别

（1）sleep()不释放锁，wait()释放锁

（2）sleep()指定休眠的时间，wait()可以指定时间也可以无限等待直到notify或notifyAll

（3）sleep()在Thread类中声明的静态方法，wait方法在Object类中声明

因为我们调用wait（）方法是由锁对象调用，而锁对象的类型是任意类型的对象。那么希望任意类型的对象都要有的方法，只能声明在Object类中。

（并发基础（互斥同步、非阻塞同步、指令重排、sychronized、volatile）、线程、锁（自旋锁、偏向锁、可重入锁）、线程池、并发容器 JUC （executor、collections、locks、atomic、tools）