Java中对象的synchronized关键字

水深无声 2022-05-11 13:22 172阅读 0赞

多线程共享同一储存空间，在带来方便的同时，也会造成访问冲突。Java语言提供了synchronized关键字已解决这种冲突，有效地避免了同一个数据对象被多个线程同时访问。使用synchronized关键字要注意一下几点：

1.  synchronized关键字可以作为函数的修饰符，也可以作为函数内的语句。synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)上。
2.  无论synchronized关键字加在方法上还是加在对象上，它取得的锁都是对象，而不是一段代码或一个函数锁定，而且同步方法很可能还会被其他线程对象访问。
3.  每个对象只有一把锁(lock)与之相关联。
4.  实现同步是要以很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无所谓的同步控制。

synchronized关键字的作用域有两种。

1.  某个对象实例内，synchronized aMethod()\{\}可以防止多个线程同时访问这个对象的synchronized方法。如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其他线程不能同时访问这个对象中的任何一个synchronized方法。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其他线程照样可以同时访问相同类的另一个对象实例中的synchronized方法。
2.  某个类的范围中，synchronized static aStaticMethod()\{\}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

synchronized方法控制对类成员变量的访问：每个类实例对应一把锁，每个synchronized方法都必须获得调用该类方法的类实例的锁方能执行，否则所属线程被阻塞，方法一旦执行，就独占该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有的声明为synchronized的成员函数中至少只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效地避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为synchronized）。

下面举个例子。一电影院有20张电影票要卖，目前有3个售票员。我们用sleep()函数来模拟售票，假设不使用synchronized关键字。

/**
     * 测试多线程情况下不使用synchronized关键字
     * @author QuLei
     *
     */
    public class SellTest {
    	public static void main(String[] args) {
    		SellThread sellThread = new SellThread();
    		 new Thread(sellThread,"售票员1").start();
    		 new Thread(sellThread,"售票员2").start();
    		 new Thread(sellThread,"售票员3").start();
    	}
    }
    
    /**
     * 一电影院有20张电影票要卖，目前有3个售票员。我们用sleep()函数来模拟售票，
     * 假设不使用synchronized关键字。
     * @author QuLei
     *
     */
    class SellThread implements Runnable{
    	private int ticketCount = 20;
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		while(true) {
    			if(ticketCount > 0) {
    				try {
    					Thread.sleep(100);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				System.out.println(Thread.currentThread().getName()+"sell "+
    						ticketCount--);
    			}else {
    				break;
    			}
    		}
    	}
    	
    }
    
    
    执行结果：
    售票员2sell 2
    售票员1sell 1
    售票员3sell 0
    售票员2sell -1

结果卖掉了22张票,如果使用synchronized关键字，就可以避免这种冲突，修改程序如下：

/**
     * 测试多线程情况下不使用synchronized关键字
     * @author QuLei
     *
     */
    public class SellTest {
    	public static void main(String[] args) {
    		//SellThread sellThread = new SellThread();
    		ThreadSell sellThread = new ThreadSell();
    		 new Thread(sellThread,"售票员1").start();
    		 new Thread(sellThread,"售票员2").start();
    		 new Thread(sellThread,"售票员3").start();
    	}
    }
    
    /**
     * 一电影院有20张电影票要卖，目前有3个售票员。我们用sleep()函数来模拟售票，
     *使用synchronized关键字。
     * @author QuLei
     *
     */
    class ThreadSell implements Runnable{
    	private int ticketCount = 20;
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		while(true) {
    			synchronized (this) {
    				if(ticketCount > 0 ) {
    					try {
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName()+
    							"sell "+ticketCount--);
    				}else {
    					break;
    				}
    			}
    		}
    	}
    	
    }
    
    执行的结果为：
    售票员3sell 5
    售票员2sell 4
    售票员2sell 3
    售票员3sell 2
    售票员1sell 1

这样就卖掉了20张票，这里锁的this即为一个对象，也可以锁一个其它的对象，这个对象被当做是一个标志位，这个标志位可以被任何一个售票员使用，这样售票员1线程拿到了其它的售票员线程发现以后就会被搁置，一直等到售票员1释放掉标志对象。

这里有两个容易误解的地方：

1.  一个线程拿到synchronized括号中的对象后，其它也需要拿到这个对象才能运行的线程不能执行了。其实其它线程也是可以执行的，但他们执行到了需要synchronized中对象的时候，发现对象的标志位不可用，只能又被搁置了，所以synchronized使线程同步的时候是以牺牲效率为代价的。
2.  一个线程拿到了synchronized括号中的对象之后，其他任何线程都不能执行了，假如其他不需要synchronized的对象才能执行的线程，还是可以和拿到synchronized的括号中的对象的线程一起运行的。有的方法在前面被加上了synchronized，其实这个时候就是把这个方法的调用者即this的标志位置0了，这样就不能和其他需要this才能运行的线程一起执行，但可以和其他不需要这个this对象的线程一起运行。