Java--多线程之synchronized和lock

系统管理员 2023-10-05 06:49 75阅读 0赞

1、synchronized

synchronized表示当前线程，独占 对象 someObject  
当前线程独占 了对象someObject，如果有其他线程试图占有对象someObject，就会等待，直到当前线程释放对someObject的占用。  
someObject 又叫同步对象，所有的对象，都可以作为同步对象  
为了达到同步的效果，必须使用同一个同步对象  
释放同步对象的方式： synchronized 块自然结束，或者有异常抛出

package MultiThread;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class TestThread3 {
    	public static String now() {
    		return new SimpleDateFormat("HH:mm:ss").format(new Date());
    	}
    	
    	public static void main(String[] args) {
    		final Object someObj = new Object();
    		
    		Thread t1 = new Thread () {
    			public void run() {
    				try {
    					System.out.println( now()+" t1 线程已经运行");
                        System.out.println( now()+this.getName()+ " 试图占有对象：someObject");
                        
                        synchronized (someObj) {
                        	System.out.println( now()+this.getName()+ " 占有对象：someObject");
                            Thread.sleep(5000);
                            System.out.println( now()+this.getName()+ " 释放对象：someObject");
    					}
                        System.out.println(now()+" t1 线程结束");
    				} catch (Exception e) {
    					// TODO: handle exception
    					e.printStackTrace();
    				}
    			}
    		};
    		t1.setName("  t1");
    		t1.start();
    		
    		Thread t2 = new Thread () {
    			public void run() {
    				try {
    					System.out.println( now()+" t2 线程已经运行");
                        System.out.println( now()+this.getName()+ " 试图占有对象：someObject");
                        
                        synchronized (someObj) {
                        	System.out.println( now()+this.getName()+ " 占有对象：someObject");
                            Thread.sleep(5000);
                            System.out.println( now()+this.getName()+ " 释放对象：someObject");
    					}
                        System.out.println(now()+" t2 线程结束");
    				} catch (Exception e) {
    					// TODO: handle exception
    					e.printStackTrace();
    				}
    			}
    		};
    		t2.setName("  t2");
    		t2.start();
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu_size_16_color_FFFFFF_t_70][]

2、线程死锁

（1） 线程1 首先占有对象1，接着试图占有对象2

（2）线程2 首先占有对象2，接着试图占有对象1

（3）线程1 等待线程2释放对象2

（4）与此同时，线程2等待线程1释放对象1

就会。。。一直等待下去，直到天荒地老

3、Lock

Lock是一个接口

与 synchronized (someObject) 类似的，lock()方法，表示当前线程占用lock对象，一旦占用，其他线程就不能占用了。  
与 synchronized 不同的是，一旦synchronized 块结束，就会自动释放对someObject的占用。 lock却必须调用unlock方法进行手动释放，为了保证释放的执行，往往会把unlock() 放在finally中进行

package MultiThread;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class TestLock {
    
    	/*与 synchronized (someObject) 类似的，lock()方法，表示当前线程占用lock对象，一旦占用，其他线程就不能占用了。
    	与 synchronized 不同的是，一旦synchronized 块结束，就会自动释放对someObject的占用。 lock却必须调用unlock方法进行手动释放，为了保证释放的执行，往往会把unlock() 放在finally中进行。
    	 * */
    	
    	/* 1. Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。
    		2. Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生。
    		3. synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 所以如果忘记了释放锁，一样会造成死锁
    	 * */
    	public static void main(String[] args) {
    		Lock lock = new ReentrantLock();
    		Condition condition = lock.newCondition();
    		
    		/* 使用synchronized方式进行线程交互，用到的是同步对象的wait,notify和notifyAll方法
    			Lock也提供了类似的解决办法，首先通过lock对象得到一个Condition对象，然后分别调用这个Condition对象的：await, signal,signalAll 方法
    			*/
    		Thread t1 = new Thread() {
    			public void run() {
    				try {
    					log("线程启动");
                        log("试图占有对象：lock");
                        
                        lock.lock();
                        
                        log("占有对象：lock");
                        log("进行5秒的业务操作");
                        Thread.sleep(5000);
                        
                        log("临时释放对象 lock， 并等待");
                        condition.await();
                        log("重新占有对象 lock，并进行5秒的业务操作");
                        Thread.sleep(5000);
    				} catch (InterruptedException e) {
    					// TODO: handle exception
    					e.printStackTrace();
    				} finally {
    					log("释放对象：lock");
    					lock.unlock();
    				}
    				log("线程结束");
    			}
    		};
    		t1.setName("t1");
    		t1.start();
    		
    		try {
                //先让t1飞2秒
                Thread.sleep(2000);
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
    		
    		Thread t2 = new Thread () {
    			public void run() {
    				try {
    					log("线程启动");
                        log("试图占有对象：lock");
                        
                        lock.lock();
                        
                        log("占有对象：lock");
                        log("进行5秒的业务操作");
                        Thread.sleep(5000);
                        
                        log("唤醒等待中的线程");
                        condition.signal();
    				} catch (InterruptedException e) {
    					// TODO: handle exception
    					e.printStackTrace();
    				} finally {
    					log("释放对象：lock");
    					lock.unlock();
    				}
    				log("线程结束");
    			}
    		};
    		t2.setName("t2");
    		t2.start();
    	}
    
    	public static String now() {
            return new SimpleDateFormat("HH:mm:ss").format(new Date());
        }
    	
    	public static void log(String msg) {
            System.out.printf("%s -- %s %s %n", now() , Thread.currentThread().getName() , msg);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu_size_16_color_FFFFFF_t_70 1][]

### 总结Lock和synchronized的区别 ###

1、Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。  
2、 Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生。  
3、 synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 所以如果忘记了释放锁，一样会造成死锁。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200917152800433.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200917153326546.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu,size_16,color_FFFFFF,t_70