JAVA多线程(一):线程之间的同步与死锁

曾经终败给现在 2022-01-14 06:49 308阅读 0赞

### 文章目录 ###

*  什么是线程安全？
 *  如何实现同步
 *   *  1.使用同步代码块
     *  2.使用同步函数
     *  3.静态同步函数
 *  线程死锁

# 什么是线程安全？ #

当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。

*  案例:需求现在有100张火车票，有两个窗口同时抢火车票，请使用多线程模拟抢票效果。

public class 多线程抢票案例MyTest { 
    
        public static void main(String[] args) { 
    
                MyThread myThread = new MyThread();
                Thread thread1 = new Thread(myThread,"第一个售票口");
                Thread thread2 = new Thread(myThread,"第二个售票口");
    
                thread1.start();
                thread2.start();
        }
    
    
    
    
    }
    
    
    class MyThread implements Runnable{ 
    
        private Integer tickNumber = 100;
    // private Object obj = new Object();
    
    
        @Override
        public  void run() { 
            while (tickNumber > 0){ 
                try { 
                    Thread.sleep(140);
                        System.out.println(Thread.currentThread().getName()+"正在抢"+(100-tickNumber+1)+"长票");
                        tickNumber -- ;
    
                } catch (InterruptedException e) { 
                }
            }
    
        }
    }

会发现，原本100张票，会出现了101张票  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQxMzE2MTc_size_16_color_FFFFFF_t_70]

# 如何实现同步 #

## 1.使用同步代码块 ##

就是将可能会发生线程安全问题的代码，给包括起来。

synchronized(同一个数据){ 
     	可能会发生线程冲突问题
    }

private Object mutex = new Object();// 自定义多线程同步锁
    	public void sale() { 
    		synchronized (mutex) { 
    			if (trainCount > 0) { 
    try { 
    					Thread.sleep(10);
    				} catch (Exception e) { 
    				}
    				System.out.println(Thread.currentThread().getName() + ",出售 第" + (100 - trainCount + 1) + "张票.");
    				trainCount--;			}
    		}
    	}

## 2.使用同步函数 ##

在方法上修饰synchronized 称为同步函数

public synchronized void sale() { 
    			if (trainCount > 0) {  
    		try { 
    					Thread.sleep(40);
    				} catch (Exception e) { 
    				}
    				System.out.println(Thread.currentThread().getName() + ",出售 第" + (100 - trainCount + 1) + "张票.");
    				trainCount--;
    			}
    	}

## 3.静态同步函数 ##

方法上加上static关键字，使用synchronized 关键字修饰 或者使用类.class文件。  
静态的同步函数使用的锁是 该函数所属字节码文件对象  
可以用 getClass方法获取，也可以用当前 类名.class 表示。

synchronized (ThreadTrain.class) { 
    			System.out.println(Thread.currentThread().getName() + 
    			",出售 第" + (100 - trainCount + 1) + "张票.");
    			
    			trainCount--;
    			try { 
    				Thread.sleep(100);
    			} catch (Exception e) { 
    			}
    }

synchronized 修饰方法使用锁是当前this锁。  
synchronized 修饰静态方法使用锁是当前类的字节码文件

# 线程死锁 #

甲：我有A锁，但我想要B锁，你先给我B锁！  
乙：我有B锁，但我想要A锁，你先给我A锁！  
互相争执，导致陷入死锁

public class 死锁案例 { 
    
        public static String lockA = "a";
        public static String lockB = "b";
    
        public static void main(String[] args) { 
            MyThreadDead1 myThreadDead1 = new MyThreadDead1();
            MyThreadDead2 myThreadDead2 = new MyThreadDead2();
            Thread t1 = new Thread(myThreadDead1,"线程1");
            Thread t2 = new Thread(myThreadDead2,"线程2");
            t1.start();
            t2.start();
    
        }
    
    
    }
    
    
    
    class MyThreadDead1 implements Runnable{ 
    
    
        @Override
        public void run() { 
            while(true){ 
                System.out.println(Thread.currentThread().getName() +": 我想要A锁");
                synchronized (死锁案例.lockA){ 
                    System.out.println(Thread.currentThread().getName() +": 我拿到A锁了！");
                    try { 
                        Thread.sleep(3000);
                    } catch (InterruptedException e) { 
    
                    }
                    System.out.println(Thread.currentThread().getName() +": 我想要B锁");
                    synchronized (死锁案例.lockB){ 
                        System.out.println(Thread.currentThread().getName() +": 我拿到B锁了！");
                    }
                }
    
            }
    
        }
    }
    
    class MyThreadDead2 implements Runnable{ 
    
    
        @Override
        public void run() { 
            while(true){ 
                System.out.println(Thread.currentThread().getName() +": 我想要B锁");
                synchronized (死锁案例.lockB){ 
                    try { 
                        Thread.sleep(3000);
                    } catch (InterruptedException e) { 
    
                    }
                    System.out.println(Thread.currentThread().getName() +": 我拿到B锁了！");
                    System.out.println(Thread.currentThread().getName() +": 我想要A锁");
                    synchronized (死锁案例.lockA){ 
                        System.out.println(Thread.currentThread().getName() +": 我拿到A锁了！");
                    }
                }
    
            }
    
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQxMzE2MTc_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQxMzE2MTc_size_16_color_FFFFFF_t_70]: /images/20220114/4ecba228763349fda0dff44bdd9965b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQxMzE2MTc_size_16_color_FFFFFF_t_70 1]: /images/20220114/837f76eb6e9e4057a4a2fe87b016ab76.png