Java 基础学习之多线程五（同步与死锁）

超、凢脫俗 2024-04-17 05:50 55阅读 0赞

**声明：** 本博客的是实例代码，不规范，正式写代码时把 main() 放到一个单独的类中会更规范一点。

## 1. 问题的引出 ##

一个多线程的程序，如果是通过 Runnable 接口实现的，则意味着类中的属性将被多个线程共享。因此，如果多个线程要操作同一资源时，就有肯出现资源同步的问题。例如前面的卖票程序，如果多个线程同时操作时，就有肯出现卖出的票数为负数的问题。

###### 实例1代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 		
    		MyThread myThread = new MyThread();                // 实例化 MyThread 对象
    		Thread thread1 = new Thread(myThread);             // 定义线程对象
    		Thread thread2 = new Thread(myThread);             // 定义线程对象
    		Thread thread3 = new Thread(myThread);             // 定义线程对象
    		thread1.start();                                   // 启动多线程
    		thread2.start();
    		thread3.start(); 
    	}
    	
        private int tickets = 5;                               // 一共 5 张票
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法 
    		for(int i = 0; i < 10; i++) {                       // 超出票数的循环
    			if(tickets > 0) { 
    				try { 
    					Thread.sleep(5000);                     // 加入延迟
    				} catch (Exception e) { 
    					System.out.println("线程休眠异常:"+e.getMessage());
    				}
    				System.out.println("卖票:tickets = "+tickets--);
    			}
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]  
   从上面的截图中可以发现，票数为 5 的时候被卖了两次，在实际当中这是不可能的。这是因为在上面的程序中，在判断票数大于 0 和卖票之间加入了延迟操作，那么一个线程就有可能在还没有对票数进行减操作之前，其他线程就已经将票数减少了。如果想解决这样的问题，就必须使用同步。所谓同步，是指多个操作在同一时间段内只能有一个线程进行，其他线程要等待此线程完成之后才可以继续执行。

## 2. 使用同步解决问题 ##

解决资源共享的同步操作，可以使用同步代码块和同步方法两种方式完成。

### 2.1 同步代码块解决问题 ###

1.  代码块是指用 “\{ \}” 括起来的一段代码，根据其位置和声明的不同，可以分为普通代码块、构造块、静态块 3 种，如果在代码块上加上 synchronized 关键字，则此代码块就称为同步代码块。同步代码块格式：

synchronized( 同步对象){ 
    需要同步的代码;
    }

1.  从格式可以看出，在使用同步代码块时必须指定一个需要同步的对象，但一般都将当前对象 （this）设置成同步对象。

###### 实例2代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 		
    		MyThread myThread = new MyThread();                // 实例化 MyThread 对象
    		Thread thread1 = new Thread(myThread);             // 定义线程对象
    		Thread thread2 = new Thread(myThread);             // 定义线程对象
    		Thread thread3 = new Thread(myThread);             // 定义线程对象
    		thread1.start();                                   // 启动多线程
    		thread2.start();
    		thread3.start(); 
    	}
    	
        private int tickets = 5;                               // 一共 5 张票
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法 
    		for(int i = 0; i < 10; i++) {                       // 超出票数的循环
    			synchronized (this) {                           // 设置需要同步的操作
    				if(tickets > 0) { 
    					try { 
    						Thread.sleep(500);                     // 加入延迟
    					} catch (Exception e) { 
    						System.out.println("线程休眠异常:"+e.getMessage());
    					}
    					System.out.println("卖票:tickets = "+tickets--);
    				}
    			}			
    		}
    	}	
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190824144518462.png]  
   从上面的运行结果可以发现，以上代码将取值和修改操作进行了同步，所以不会出现一张票卖了两次的情况。

### 2.2 同步方法解决问题 ###

除了可以将需要的代码设置成同步代码块之外，也可以使用 synchronized 关键字将一个方法声明成同步方法。同步方法格式如下：

synchronized 方法返回值类型 方法名称（参数列表）{ 
    // 方法体
    }

###### 实例3代码： ######

package self.learn.thread;
    
    public class MyThread implements Runnable {                  // 实现 Runnable 接口
    
    	public static void main(String[] args) { 		
    		MyThread myThread = new MyThread();                // 实例化 MyThread 对象
    		Thread thread1 = new Thread(myThread);             // 定义线程对象
    		Thread thread2 = new Thread(myThread);             // 定义线程对象
    		Thread thread3 = new Thread(myThread);             // 定义线程对象
    		thread1.start();                                   // 启动多线程
    		thread2.start();
    		thread3.start(); 
    	}
    	
        private int tickets = 5;                               // 一共 5 张票
    	public void run() {                                     //覆写 Runnable 接口中 run() 方法 
    		for(int i = 0; i < 10; i++) {                       // 超出票数的循环
    			this.sale();			
    		}
    	}
    	
    	public synchronized void sale() {                        //声明同步方法 
    		if(tickets > 0) { 
    			try { 
    				Thread.sleep(500);                          //加入延迟
    			} catch (Exception e) { 
    				System.out.println("线程休眠异常:"+e.getMessage());
    			}
    			System.out.println("卖票:tickets = "+tickets--);
    		}
    	}
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190824150607218.png]  
   从上面的程序运行结果中可以发现，此代码完成了与之前同步代码块同样的功能。

## 3. 死锁 ##

死锁：就是指两个线程在等待彼此先完成，造成了停滞状态。 一般程序的死锁是在程序运行时出现。

###### 实例4代码： ######

package self.learn.deadlock;
    
    public class Zhangsan {                     // 定义表示张三的类
    	public void say() { 
    		System.out.println("张三对李四说：你给我画，我把书给你");
    	}
    	public void get() { 
    		System.out.println("张三得到了画");
    	}
    
    }

package self.learn.deadlock;
    
    public class Lisi {                                 // 定义表示李四的类
    	public void say() { 
    		System.out.println("李四对张三说：你给我书，我就把画给你");
    	}
    	public void get() { 
    		System.out.println("李四得到了书");
    	}
    
    }

package self.learn.deadlock;
    
    public class ThreadDeadLock implements Runnable {    // 定义多线程类
    	private static Zhangsan zs = new Zhangsan();    // 实列化 static 对象，数据共
    	private static Lisi ls = new Lisi();
    	private boolean flag = false;                  // 声明标记，用于判断哪个对象先执行
    	@Override
    	public void run() {                             // 覆写 run 方法 
    		if(flag) {                                  // 判断标志位，Zhangsan 先执行
    			synchronized (zs) {                     // 同步第 1 个对象
    				zs.say();
    				try { 
    					Thread.sleep(1000);           // 加入延迟
    				} catch (InterruptedException e) { 
    					e.printStackTrace();
    					System.out.println("线程休眠出现异常"+e.getMessage());
    				}
    				synchronized (ls) {                  // 同步第 2 个对象
    					zs.get();
    				}
    			}
    		}else{                                      // Lisi 先执行
    			synchronized (ls) {                      // 同步第 2 个对象
    				ls.say();
    				try { 
    					Thread.sleep(1000);             // 加入延迟
    				} catch (InterruptedException e) { 
    					e.printStackTrace();
    					System.out.println("线程休眠出现异常"+e.getMessage());
    				}
    				synchronized (zs) {                   // 同步第 1 个对象
    					ls.get();
    				}
    			}
    		}
    
    	}
    	
    	public static void main(String args[]) { 
    		ThreadDeadLock t1 = new ThreadDeadLock();    // 实例化线程对象
    		ThreadDeadLock t2 = new ThreadDeadLock();
    		t1.flag = true;                              // 设置标记
    		t2.flag = false;
    		Thread thread1 = new Thread(t1);            // 实例化 Thread 类对象
    		Thread thread2 = new Thread(t2);
    		thread1.start();                             // 启动线程
    		thread2.start();
    	}
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190824161427528.png]  
   从结果中可以发现，两个线程都在等待着对方的执行完成。这样，程序就无法向下继续执行，从而造成了死锁现象。  
**同步与死锁的使用：**  
   多个线程共享同一资源时需进行同步，以保证资源操作的完整性，但是过多的同步就有可能产生死锁。

## 4.常见面试题 ##

1.  请解释多个线程访问同一资源时需考虑哪些情况？有可能带来哪些问题？  
    （1）多个线程访问同一资源时，考虑数据的安全性问题，一定要使用同步操作。同步有以下两种操作模式：  
    a. 同步代码块：synchronized （锁定对象）\{代码\}  
    b. 同步方法：public synchronized 返回值类型 方法名称（）\{代码\}  
    （2）过多的同步操作有可能会带来死锁问题，导致程序进入停滞状态。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/4e15d66c353f49be8186370ec1be7e59.png
[20190824144518462.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/5a34c0f7216b47e7b51d1f65d5e2ce4e.png
[20190824150607218.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/3339e91336ac45a48813ffa7fd190868.png
[20190824161427528.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/0dc936cd4d2345d3b2fa9509a2dfb720.png