Java基础进阶多线程-线程安全和synchronized关键字

一时失言乱红尘 2023-10-08 16:54 70阅读 0赞

#### 文章目录 ####

*   *  为什么线程安全这个是重点
     *  什么时候数据在多线程并发的环境下会存在安全问题呢？
     *  怎么解决线程安全问题呢？
     *   *  异步编程模型：
         *  同步编程模型：
     *  Java中有三大变量？【重要的内容。】
     *   *  synchronized有三种写法：
         *   *  示例代码01：
             *  运行结果：
             *  示例代码02：
             *  运行结果：
             *  示例代码03：
             *  运行结果：
         *  synchronized面试题01：
         *   *  示例代码04：
             *  运行结果：
         *  synchronized面试题02：
         *   *  示例代码05：
             *  运行结果：
         *  synchronized面试题03：
         *   *  示例代码06：
             *  运行结果：
         *  synchronized面试题04：
         *   *  示例代码07：
             *  运行结果：

关于多线程并发环境下，数据的安全问题。

### 为什么线程安全这个是重点 ###

> 以后在开发中，我们的项目都是运行在服务器当中，  
> 而服务器已经将线程的定义，线程对象的创建，线程  
> 的启动等，都已经实现完了。这些代码我们都不需要  
> 编写。
> 
> 最重要的是：你要知道，你编写的程序需要放到一个  
> 多线程的环境下运行，你更需要关注的是这些数据  
> 在多线程并发的环境下是否是安全的（重点：\*\*\*\*\*）

### 什么时候数据在多线程并发的环境下会存在安全问题呢？ ###

三个条件：

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

满足以上3个条件之后，就会存在线程安全问题。

### 怎么解决线程安全问题呢？ ###

当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在  
线程安全问题，怎么解决这个问题？

*  线程排队执行。（不能并发）。
 *  用排队执行解决线程安全问题。
 *  这种机制被称为：线程同步机制。

专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。

*  使用“线程同步机制”。
 *  线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全  
    第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

说到线程同步这块，涉及到这两个专业术语：

#### 异步编程模型： ####

*  线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，  
    谁也不需要等谁，这种编程模型叫做：异步编程模型。  
    其实就是：多线程并发（效率较高。）

> 异步就是并发。

#### 同步编程模型： ####

*  线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行  
    结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，  
    两个线程之间发生了等待关系，这就是同步编程模型。  
    效率较低。线程排队执行。

> 同步就是排队。

### Java中有三大变量？【重要的内容。】 ###

*  实例变量：在堆中。
 *  静态变量：在方法区。
 *  局部变量：在栈中。

以上三大变量中：

*  局部变量永远都不会存在线程安全问题。  
    因为局部变量不共享。（一个线程一个栈。）=  
    局部变量在栈中。所以局部变量永远都不会共享
 *  实例变量在堆中，堆只有1个
 *  静态变量在方法区中，方法区只有1个
 *  堆和方法区都是多线程共享的，所以可能存在线程安全问题

局部变量+常量：不会有线程安全问题  
成员变量：可能会有线程安全问题。

如果使用局部变量的话：  
建议使用：StringBuilder。  
因为局部变量不存在线程安全问题。选择StringBuilder。  
StringBuffer效率比较低。

> ArrayList是非线程安全的。  
> Vector是线程安全的。  
> HashMap HashSet是非线程安全的。  
> Hashtable是线程安全的。

#### synchronized有三种写法： ####

第一种：同步代码块

>     灵活
>     	synchronized(线程共享对象){
>          
>     		同步代码块;
>     	}

synchronized后面小括号中传的这个“数据”是相当关键的。  
这个数据必须是多线程共享的数据。才能达到多线程排队。

*  ()中写什么？  
    那要看你想让哪些线程同步。  
    假设t1、t2、t3、t4、t5，有5个线程，  
    你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？  
    你一定要在()中写一个t1 t2 t3共享的对象。而这个  
    对象对于t4 t5来说不是共享的。
 *  >     //Object obj2 = new Object();
    >     //synchronized (this){
    >            
    >     //synchronized (obj) {
    >            
    >     //synchronized ("abc") { // "abc"在字符串常量池当中。
    >     //synchronized (null) { // 报错：空指针。
    >     //synchronized (obj2) { // 这样编写就不安全了。因为obj2不是共享对象。
    >     //synchronized(this){

第二种：在实例方法上使用synchronized

*  表示共享对象一定是this  
    并且同步代码块是整个方法体。

第三种：在静态方法上使用synchronized  
表示找类锁。  
类锁永远只有1把。  
就算创建了100个对象，那类锁也只有一把。

> 对象锁：1个对象1把锁，100个对象100把锁。  
> 类锁：100个对象，也可能只是1把类锁。

开发中应该怎么解决线程安全问题？

是一上来就选择线程同步吗？synchronized  
不是，synchronized会让程序的执行效率降低，用户体验不好。  
系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择  
线程同步机制。

*  第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
 *  第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样  
    实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，  
    对象不共享，就没有数据安全问题了。）
 *  第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候  
    就只能选择synchronized了。线程同步机制。

##### 示例代码01： #####

/*
    银行账户
        不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。
     */
    public class Account implements Serializable{
        
        private static final long serialVersionUID = 1655286831056942086L;
        //账户
        private String actno;
        //余额
        private double balance;
    
        public Account() {
        
        }
    
        public Account(String actno, int balance) {
        
            this.actno = actno;
            this.balance = balance;
        }
    
        public String getActno() {
        
            return actno;
        }
    
        public void setActno(String actno) {
        
            this.actno = actno;
        }
    
        public double getBalance() {
        
            return balance;
        }
    
        public void setBalance(double balance) {
        
            this.balance = balance;
        }
    
        //取款方法
        public void withdraw(double money){
        
    
            //取款之前的余额
            // t1和t2并发这个方法。。。。（t1和t2是两个栈。两个栈操作堆中同一个对象。）
           double before = this.getBalance();
            //取款之后的余额
            double after = before - money;
    
            // 在这里模拟一下网络延迟，100%会出现问题
            try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            //更新余额
            // 思考：t1执行到这里了，但还没有来得及执行这行代码，t2线程进来withdraw方法了。此时一定出问题。
            this.setBalance(after);
        }
    }
    public class AccountThread extends Thread{
        
    
        // 两个线程必须共享同一个账户对象。
        private Account act;
    
        // 通过构造方法传递过来账户对象
        public AccountThread(Account act){
        
            this.act = act;
        }
    
        public Account getAct() {
        
            return act;
        }
    
        public void setAct(Account act) {
        
            this.act = act;
        }
    
        public void run(){
        
    
            //取款5000
            // run方法的执行表示取款操作。
            // 假设取款5000
            double money = 5000;
    
            // 取款
            // 多线程并发执行这个方法。
            act.withdraw(money);
    
            System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功，" + "账户余额为：" + act.getBalance());
        }
    }
    public class Test {
        
        public static void main(String[] args) {
        
    
            // 创建账户对象（只创建1个）
            Account act = new Account("act-no",10000);
    
            // 创建两个线程
            Thread t1 = new AccountThread(act);
            Thread t2 = new AccountThread(act);
            // 设置name
            t1.setName("t1");
            t2.setName("t2");
            // 启动线程取款
            t1.start();
            t2.start();
    
        }
    }

##### 运行结果： #####

![在这里插入图片描述][55a74df099d44eb192be46cc2fd76274.png]

##### 示例代码02： #####

/*
    银行账户
        不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。
     */
    public class Account {
        
        //账户
        private String actno;
        //余额
        private double balance;
    
        //对象
        Object obj = new Object(); // 实例变量。（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）
    
        public Account() {
        
        }
    
        public Account(String actno, int balance) {
        
            this.actno = actno;
            this.balance = balance;
        }
    
        public String getActno() {
        
            return actno;
        }
    
        public void setActno(String actno) {
        
            this.actno = actno;
        }
    
        public double getBalance() {
        
            return balance;
        }
    
        public void setBalance(double balance) {
        
            this.balance = balance;
        }
    
        //取款方法
        public void withdraw(double money){
        
    
            // 以下这几行代码必须是线程排队的，不能并发。
            // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
            /*
            线程同步机制的语法是：
                synchronized(){
                    // 线程同步代码块。
                }
                synchronized后面小括号中传的这个“数据”是相当关键的。
                这个数据必须是多线程共享的数据。才能达到多线程排队。
    
                ()中写什么？
                    那要看你想让哪些线程同步。
                    假设t1、t2、t3、t4、t5，有5个线程，
                    你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？
                    你一定要在()中写一个t1 t2 t3共享的对象。而这个
                    对象对于t4 t5来说不是共享的。
    
                这里的共享对象是：账户对象。
                账户对象是共享的，那么this就是账户对象吧！！！
                不一定是this，这里只要是多线程共享的那个对象就行。
                在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）
                100个对象，100把锁。1个对象1把锁。
    
                以下代码的执行原理？
                    1、假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
                    2、假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，
                    找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是
                    占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
                    3、假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面
                    共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，
                    直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后
                    t2占有这把锁之后，进入同步代码块执行程序。
    
                    这样就达到了线程排队执行。
                    这里需要注意的是：这个共享对象一定要选好了。这个共享对象一定是你需要排队
                    执行的这些线程对象所共享的。
             */
            //Object obj2 = new Object();
            //synchronized (this){
        
            //synchronized (obj) {
        
            //synchronized ("abc") { // "abc"在字符串常量池当中。
            //synchronized (null) { // 报错：空指针。
            //synchronized (obj2) { // 这样编写就不安全了。因为obj2不是共享对象。
            //synchronized(this){
        
                double before = this.getBalance();
                double after = before - money;
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                this.setBalance(after);
    
        }
    }
    public class AccountThread extends Thread{
        
    
        // 两个线程必须共享同一个账户对象。
        private Account act;
    
        // 通过构造方法传递过来账户对象
        public AccountThread(Account act){
        
            this.act = act;
        }
    
        public Account getAct() {
        
            return act;
        }
    
        public void setAct(Account act) {
        
            this.act = act;
        }
    
        public void run(){
        
    
            //取款5000
            // run方法的执行表示取款操作。
            // 假设取款5000
            double money = 5000;
    
            // 取款
            // 多线程并发执行这个方法。
            //synchronized (this){//这里的this是AccountThread对象，这个对象不共享！
            synchronized (act) {
        //这种方式也可以，只不过扩大了同步的范围，效率更低了
                act.withdraw(money);
            }
            System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功，" + "账户余额为：" + act.getBalance());
        }
    }
    public class Test {
        
        public static void main(String[] args) {
        
    
            // 创建账户对象（只创建1个）
            Account act = new Account("act-no",10000);
    
            // 创建两个线程
            Thread t1 = new AccountThread(act);
            Thread t2 = new AccountThread(act);
            // 设置name
            t1.setName("t1");
            t2.setName("t2");
            // 启动线程取款
            t1.start();
            t2.start();
    
        }
    }

##### 运行结果： #####

![在这里插入图片描述][c1eebf4ddfd8467ba42258bc8b4a610f.png]

##### 示例代码03： #####

/*
    银行账户
        不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。
     */
    public class Account implements Serializable{
        
        private static final long serialVersionUID = 1655286831056942086L;
        //账户
        private String actno;
        //余额
        private double balance;
    
        public Account() {
        
        }
    
        public Account(String actno, int balance) {
        
            this.actno = actno;
            this.balance = balance;
        }
    
        public String getActno() {
        
            return actno;
        }
    
        public void setActno(String actno) {
        
            this.actno = actno;
        }
    
        public double getBalance() {
        
            return balance;
        }
    
        public void setBalance(double balance) {
        
            this.balance = balance;
        }
    
        //取款方法
        /*
        在实例方法上可以使用synchronized吗？可以的。
            synchronized出现在实例方法上，一定锁的是this。
            没得挑。只能是this。不能是其他的对象了。
            所以这种方式不灵活。
    
            另外还有一个缺点：synchronized出现在实例方法上，
            表示整个方法体都需要同步，可能会无故扩大同步的
            范围，导致程序的执行效率降低。所以这种方式不常用。
    
            synchronized使用在实例方法上有什么优点？
                代码写的少了。节俭了。
    
            如果共享的对象就是this，并且需要同步的代码块是整个方法体，
            建议使用这种方式。
         */
        public synchronized void withdraw(double money){
        
    
           double before = this.getBalance();
            double after = before - money;
            try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }
    public class AccountThread extends Thread{
        
    
        // 两个线程必须共享同一个账户对象。
        private Account act;
    
        // 通过构造方法传递过来账户对象
        public AccountThread(Account act){
        
            this.act = act;
        }
    
        public Account getAct() {
        
            return act;
        }
    
        public void setAct(Account act) {
        
            this.act = act;
        }
    
        public void run(){
        
    
            //取款5000
            // run方法的执行表示取款操作。
            // 假设取款5000
            double money = 5000;
    
            // 取款
            // 多线程并发执行这个方法。
            act.withdraw(money);
    
            System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功，" + "账户余额为：" + act.getBalance());
        }
    }
    public class Test {
        
        public static void main(String[] args) {
        
    
            // 创建账户对象（只创建1个）
            Account act = new Account("act-no",10000);
    
            // 创建两个线程
            Thread t1 = new AccountThread(act);
            Thread t2 = new AccountThread(act);
            // 设置name
            t1.setName("t1");
            t2.setName("t2");
            // 启动线程取款
            t1.start();
            t2.start();
    
        }
    }

##### 运行结果： #####

![在这里插入图片描述][73917c1a87794136933e619e98526dcb.png]

#### synchronized面试题01： ####

doOther方法执行的时候需要等待doSome方法的结束吗？不需要

因为doOther方法没有sychronized关键字，所以doOther方法不需要到锁池中获取锁

##### 示例代码04： #####

public class Exam01 {
        
        public static void main(String[] args) {
        
            MyClass c = new MyClass();
    
            MyThread t1 = new MyThread(c);
            MyThread t2 = new MyThread(c);
    
            t1.setName("t1");
            t2.setName("t2");
            t1.start();
            try {
        
                Thread.sleep(1000);//这个睡眠的作用是：为了保证t1线程先执行。
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            t2.start();
    
        }
    }
    
    class MyThread extends Thread {
        
        private MyClass mc;
    
        public MyThread(MyClass mc) {
        
            this.mc = mc;
        }
    
        public void run() {
        
    
            if(Thread.currentThread().getName().equals("t1")){
        
                mc.doSome();
            }
            if(Thread.currentThread().getName().equals("t2")){
        
                mc.doOther();
            }
        }
    }
    class MyClass {
        
    
            public synchronized void doSome() {
        
                System.out.println("doSome beign");
                try {
        
                    Thread.sleep(1000 * 5);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("doSome over");
            }
    
            public void doOther() {
        
                System.out.println("doOther beign");
                System.out.println("doOther over");//因为doOther方法没有sychronized关键字，所以doOther方法不需要到锁池中获取锁
            }
        }

##### 运行结果： #####

![在这里插入图片描述][5394e336b3ab49e7a1c9a4a5c1a6634d.png]

#### synchronized面试题02： ####

doOther方法执行的时候需要等待doSome方法的结束吗？需要

因为doOther方法有sychronized关键字，所以doOther方法需要排队（等待doSome方法执行玩释放锁之后）获取锁

##### 示例代码05： #####

public class Exam02 {
        
            public static void main(String[] args) {
        
    
                MyClass1 a = new exam.MyClass1();
                MyThread1 t3 = new exam.MyThread1(a);
                MyThread1 t4 = new exam.MyThread1(a);
    
                t3.setName("t3");
                t4.setName("t4");
                t3.start();
                try {
        
                    Thread.sleep(1000);//这个睡眠的作用是：为了保证t1线程先执行。
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                t4.start();
    
            }
        }
    
    class MyThread1 extends Thread {
        
            private MyClass1 mc;
    
            public MyThread1(MyClass1 mc) {
        
                this.mc = mc;
            }
    
            public void run() {
        
    
                if(Thread.currentThread().getName().equals("t3")){
        
                    mc.doSome();
                }
                if(Thread.currentThread().getName().equals("t4")){
        
                    mc.doOther();
                }
            }
        }
    class MyClass1 {
        
            public synchronized void doSome() {
        
                System.out.println("doSome beign");
                try {
        
                    Thread.sleep(1000 * 5);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("doSome over");
            }
    
            public synchronized void doOther() {
        
                System.out.println("doOther beign");
                System.out.println("doOther over");//因为doOther方法有sychronized关键字，所以doOther方法需要排队（等待doSome方法执行玩释放锁之后）获取锁
            }
        }

##### 运行结果： #####

![在这里插入图片描述][603ca46a23db4d229205194999edfe22.png]

#### synchronized面试题03： ####

doOther方法执行的时候需要等待doSome方法的结束吗？不需要

因为MyClass对象是两个，两把锁。

##### 示例代码06： #####

public class Exam03 {
        
            public static void main(String[] args) {
        
                MyClass2 c1 = new MyClass2();
                MyClass2 c2 = new MyClass2();//创建两个对象就没有共享对象了,不需要排队获取锁
    
                MyThread2 t1 = new MyThread2(c1);
                MyThread2 t2 = new MyThread2(c2);
    
                t1.setName("t1");
                t2.setName("t2");
                t1.start();
                try {
        
                    Thread.sleep(1000);//这个睡眠的作用是：为了保证t1线程先执行。
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                t2.start();
    
            }
        }
    
        class MyThread2 extends Thread {
        
            private MyClass2 mc;
    
            public MyThread2(MyClass2 mc) {
        
                this.mc = mc;
            }
    
            public void run() {
        
    
                if(Thread.currentThread().getName().equals("t1")){
        
                    mc.doSome();
                }
                if(Thread.currentThread().getName().equals("t2")){
        
                    mc.doOther();
                }
            }
        }
        class MyClass2 {
        
    
            public synchronized void doSome() {
        
                System.out.println("doSome beign");
                try {
        
                    Thread.sleep(1000 * 5);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("doSome over");
            }
    
            public synchronized void doOther() {
        
                System.out.println("doOther beign");
                System.out.println("doOther over");
            }
        }

##### 运行结果： #####

![在这里插入图片描述][ce3a9bbd599649c0a2f91858d6f87bf5.png]

#### synchronized面试题04： ####

doOther方法执行的时候需要等待doSome方法的结束吗？需要

因为静态方法是类锁，不管创建了几个对象，类锁只有。

##### 示例代码07： #####

public class Exam04 {
        
        public static void main(String[] args) {
        
    
            MyClass2 c = new MyClass2();
    
            MyThread2 t1 = new MyThread2(c);
            MyThread2 t2 = new MyThread2(c);
    
            t1.setName("t1");
            t2.setName("t2");
            t1.start();
            try {
        
                Thread.sleep(1000);//这个睡眠的作用是：为了保证t1线程先执行。
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            t2.start();
    
        }
    }
    
    class MyThread3 extends Thread {
        
        private MyClass3 mc;
    
        public MyThread3(MyClass3 mc) {
        
            this.mc = mc;
        }
    
        public void run() {
        
    
            if(Thread.currentThread().getName().equals("t1")){
        
                mc.doSome();
            }
            if(Thread.currentThread().getName().equals("t2")){
        
                mc.doOther();
            }
        }
    }
    // synchronized出现在静态方法上是找类锁。
    class MyClass3 {
        
    
        public synchronized static void doSome() {
        
            System.out.println("doSome beign");
            try {
        
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("doSome over");
        }
    
        public synchronized static void doOther() {
        
            System.out.println("doOther beign");
            System.out.println("doOther over");
        }
    }

##### 运行结果： #####

![在这里插入图片描述][bd938312d75d4b5b9e8544438f877073.png]

[55a74df099d44eb192be46cc2fd76274.png]: https://img-blog.csdnimg.cn/55a74df099d44eb192be46cc2fd76274.png
[c1eebf4ddfd8467ba42258bc8b4a610f.png]: https://img-blog.csdnimg.cn/c1eebf4ddfd8467ba42258bc8b4a610f.png
[73917c1a87794136933e619e98526dcb.png]: https://img-blog.csdnimg.cn/73917c1a87794136933e619e98526dcb.png
[5394e336b3ab49e7a1c9a4a5c1a6634d.png]: https://img-blog.csdnimg.cn/5394e336b3ab49e7a1c9a4a5c1a6634d.png
[603ca46a23db4d229205194999edfe22.png]: https://img-blog.csdnimg.cn/603ca46a23db4d229205194999edfe22.png
[ce3a9bbd599649c0a2f91858d6f87bf5.png]: https://img-blog.csdnimg.cn/ce3a9bbd599649c0a2f91858d6f87bf5.png
[bd938312d75d4b5b9e8544438f877073.png]: https://img-blog.csdnimg.cn/bd938312d75d4b5b9e8544438f877073.png