Synchronized的用法

Dear 丶 2021-10-23 10:47 391阅读 0赞

*  在上一篇的实现售票系统中，我们使用到了synchronized，相信大家也知道了为什么要使用synchronized，它能**避免多个线程同时竞争一把锁**，拿到锁的线程进行执行，等待线程出来后，继续竞争–执行；
 *  接下来还是以售票系统来说明synchronized的用法：
    
        分为三类：
          	1.同步代码块
          		锁的是代码块。要传入同一对象资源，如字符串
          	2.同步方法：在方法中加 synchronized
          		通过继承Thread类方式 需要在同步方法中加static
          		通过实现Runnable方式，则不需要
          	3.对象互斥锁(使用最少)
          		容易出现死锁
          		是一个接口，要实例化互斥对象锁
          		Lock lock = new ReentrantLock();
          		lock.lock()加锁
          		lock.unlock()释放锁
          		使用try{ lock.lock() }finally{ lock.unlock() }
          		保证只加一次锁以及只释放一次
 *  上一篇已经介绍了同步代码块，下面分别介绍synchronized在继承Thread类和实现Runnable的方式中的使用。**【注意】：要确定锁的范围，以及锁的对象。**

#### 一、通过继承Thread类 ####

*  同步方法

package com.hym.threads;
    
    public class TicketSysTest {
    	public static void main(String[] args) {
    
    		for (int i = 1; i < 6; i++) {
    			new Ticket("[ 窗口00" + i + " ]").start();
    		}
    	}
    }
    
    class Ticket extends Thread {
    	// 定义 为静态实现共享
    	private static int ticket = 100;
    
    	public Ticket(String name) {
    		super(name);
    	}
    
    	@Override
    	public void run() {
    
    		while (true) {
    			try {
    				// 使用sleep()是为了避免复现问题，让其余窗口更好的卖票..
    				Thread.sleep(100);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			if (!fun2()) {
    				break;
    			}
    		}
    	}
    
    	// 此处为同步方法，注意使用方法。在方法内加入 synchronized关键字，并且为了确保琐住要加入static
    	private static synchronized boolean fun2() {
    		if (ticket > 0) {
    			System.out.println(Thread.currentThread().getName() + "正在出售第"
    					+ ticket + "张票");
    			ticket--;
    			return true;
    		} else {
    			System.out.println(Thread.currentThread().getName() + "已售完");
    			return false;
    		}
    	}
    }

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

*  对象互斥锁

package com.hym.threads;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class TicketSysTest2 {
    	public static void main(String[] args) {
    
    		for (int i = 1; i < 6; i++) {
    			new Ticket2("[ 窗口00" + i + " ]").start();
    		}
    	}
    }
    
    class Ticket2 extends Thread {
    	// 定义 为静态实现共享
    	private static int ticket = 100;
    	//实例化互斥对象锁 为保证为同一把锁，也定义为私有的。
    	private static Lock lock = new ReentrantLock();
    	public Ticket2(String name) {
    		super(name);
    	}
    
    	@Override
    	public void run() {
    		while (true) {
    			try {
    				// 使用sleep()是为了避免复现问题，让其余窗口更好的卖票..
    				Thread.sleep(100);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			//使用try{}finally{}的方法，保证上一次锁只释放一次。避免死锁的情况出现。主要是针对最后break()出现的情况。
    			try{
    				lock.lock();
    				if (ticket > 0) {
    					System.out.println(Thread.currentThread().getName() + "正在出售第"
    							+ ticket + "张票");
    					ticket--;
    				} else {
    					System.out.println(Thread.currentThread().getName() + "已售完");
    					break;
    				}				
    			}finally{
    				lock.unlock();				
    			}
    		}
    	}
    }

#### 二、通过实现Runnable接口 ####

*  同步方法

package com.hym.threads;
    
    public class TicketRunTest {
    
    	public static void main(String[] args) {
    		TicketRun ticketRun = new TicketRun();
    		for (int i = 1; i < 6; i++) {
    			new Thread(ticketRun, "[ 窗口00" + i + " ]").start();
    		}
    	}
    }
    
    class TicketRun implements Runnable {
    	// 票数，因为传过来的都是同一个TicketRun()对象，所以不需要static也可以
    	private int ticket = 100;
    
    	@Override
    	public void run() {
    		while (true) {
    			try {
    				Thread.sleep(100);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			if(!fun2()){
    				break;
    			}
    		}
    	}
    	//同步方法 此处不用static 因为对象为在Test中定义好的ticketRun对象，为同一个
    	private synchronized boolean fun2() {
    		if (ticket > 0) {
    			System.out.println(Thread.currentThread().getName() + "正在出售第"
    					+ ticket + "张票");
    			ticket--;
    			return true;
    		} else {
    			System.out.println(Thread.currentThread().getName() + "已售完...");
    			return false;
    		}
    	}
    }

*  互斥对象锁

package com.hym.threads;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class TicketRunTest {
    
    	public static void main(String[] args) {
    		TicketRun ticketRun = new TicketRun();
    		for(int i=1;i<6;i++){
    			new Thread(ticketRun,"[ 窗口00"+i+" ]").start();
    		}
    	}
    }
    
    class TicketRun implements Runnable{
    	//票数，因为传过来的都是同一个TicketRun()对象，所以不需要static也可以
    	private int ticket = 100;
    	//实例化互斥对象锁
    	Lock lock = new ReentrantLock();
    	@Override
    	public void run() {
    		while(true){
    			try {
    				Thread.sleep(100);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			try{
    				lock.lock();
    				if(ticket>0){
    					System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
    					ticket--;
    				}else{
    					System.out.println(Thread.currentThread().getName()+"已售完...");
    					break;
    				}				
    			}finally{
    				lock.unlock();
    			}
    		}
    	}
    }

*  **大家要注意两种不同方式中使用锁的区别；**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1eW1p_size_16_color_FFFFFF_t_70]: /images/20211023/908e3c98b134491398d45b1e02edc128.png