Java多线程synchronized几种方式

于 2017-06-15 11:22:04 发布
阅读量507 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liupeng_qwert/article/details/73277117

前提概要：在Object类notify方法定义时有这样一段描述

  * This method should only be called by a thread that is the owner
     * of this object's monitor. A thread becomes the owner of the
     * object's monitor in one of three ways:
     * <ul>
     * <li>By executing a synchronized instance method of that object.
     * <li>By executing the body of a {@code synchronized} statement
     *     that synchronizes on the object.
     * <li>For objects of type {@code Class,} by executing a
     *     synchronized static method of that class.
     * </ul>
     * <p>
     * Only one thread at a time can own an object's monitor.
     *
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @see        java.lang.Object#notifyAll()
     * @see        java.lang.Object#wait()
     */
    public final native void notify();


1、synchronized三种类型：synchronized instance  method、synchronized  block 及 synchronized static method

2、代码测试：两个不同线程访问同一个类同一个方法，查看输出结果，目标是不希望出现交叉访问

（1）不加synchronized

public class NoSyncronize {
	public static void main(String[] args) {
		final Table tObj = new Table();   // 两个线程共享对象
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				tObj.print(5);
			}
		});
		
		Thread t2 = new Thread(new Runnable(){
			
			@Override
			public void run(){
				tObj.print(100);
			}
		});
		
		t1.start();
		t2.start();
	}

}

class Table {
	public void print(int n){
		for(int i=1; i<= 5; i++){
			System.out.println(n*i);

		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		}
	}
}

输出结果 

100
5
10
200
15
300
20
400
500
25

结论：出现了交叉访问，容易导致数据不一致性


（2）使用synchronized instance  method

public class SyncronizeMethod {

	public static void main(String[] args) {
		final Table2 tObj = new Table2();   // 共享对象
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				tObj.print(5);
			}
		});
		
		Thread t2 = new Thread(new Runnable(){
			
			@Override
			public void run(){
				tObj.print(100);
			}
		});
		
		t1.start();
		t2.start();
	}

}

class Table2 {
	synchronized public void print(int n){
		for(int i=1; i<= 5; i++){
			System.out.println(n*i);
	
		
		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		}
	}
}

输出结果 

5
10
15
20
25
100
200
300
400
500

结论：没有出现交叉访问，不会出现数据不一致性


（3）使用synchronized block，与synchronized instance method区别？（可以缩小同步范围，只对方法内部分代码行进行访问限制，如果对所有代码行进行限制，则等同于 synchronized instance method）

public class SyncronizeBlock {

	public static void main(String[] args) {
		final Table3 tObj = new Table3();   // 共享对象
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				tObj.print(5);
			}
		});
		
		Thread t2 = new Thread(new Runnable(){
			
			@Override
			public void run(){
				tObj.print(100);
			}
		});
		
		t1.start();
		t2.start();
	}

}

class Table3 {
	 public void print(int n){
		 synchronized (this) {    // 等同于synchronized method方式
			 for(int i=1; i<= 5; i++){
				
				System.out.println(n*i);
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				}
		}
	}
}

输出结果 

5
10
15
20
25
100
200
300
400
500

（4）使用synchronized static  method，相当于类锁，对该类所有对象适用，即同一时刻只能有一个线程访问该类的对象


不使用synchronized static 方式，仍然使用synchronized  instance方式，测试一下

public class SyncronizeStatic {

	public static void main(String[] args) {
		final Table4 tObj = new Table4();   // thread1和thread2共享对象tObj
		final Table4 tObj2 = new Table4();  // thread3和thread4共享对象tObj2
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				tObj.print(1);
			}
		});
		
		Thread t2 = new Thread(new Runnable(){
			
			@Override
			public void run(){
				tObj.print(10);
			}
		});
		
		Thread t3 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				tObj2.print(100);
			}
		});
		
		Thread t4 = new Thread(new Runnable(){
			
			@Override
			public void run(){
				tObj2.print(1000);
			}
		});
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}

class Table4 {
	 synchronized   public void print(int n){
			 for(int i=1; i<= 5; i++){
				
				System.out.println(n*i);
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				}
		}	
	 }

输出以下结果，可以看出thread1和thread2没有出现交叉访问，但是thread1和thread3、thread2和thread4出现了交叉访问情况 

10
1000
20
2000
3000
30
40
4000
50
5000
1
100
200
2
3
300
400
4
5
500

使用synchronized static method方式 

public class SyncronizeStatic {

	public static void main(String[] args) {
		final Table4 tObj = new Table4();   // thread1和thread2共享对象tObj
		final Table4 tObj2 = new Table4();  // thread3和thread4共享对象tObj2
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				Table4.print(1);
			}
		});
		
		Thread t2 = new Thread(new Runnable(){
			
			@Override
			public void run(){
				Table4.print(10);
			}
		});
		
		Thread t3 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				Table4.print(100);
			}
		});
		
		Thread t4 = new Thread(new Runnable(){
			
			@Override
			public void run(){
				Table4.print(1000);
			}
		});
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}

class Table4 {
	 synchronized  static public void print(int n){
			 for(int i=1; i<= 5; i++){
				
				System.out.println(n*i);
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				}
		}	
	 }


输出结果：

1
2
3
4
5
100
200
300
400
500
1000
2000
3000
4000
5000
10
20
30
40
50

结果：各个线程没有出现交叉访问情形

3、加锁方法与不加锁方法多线程并发访问

         加锁或同步只是针对synchronized修饰的代码块（方法：实例方法/静态方法;方法内代码块）,保证这段代码【同一时刻只能由一个线程访问,一个线程访问结束后才允许另    一个线程进入】
     对没有使用syncronized修饰的类的其它成员方法【同一时刻允许多个线程进入访问】。syncronized不是说将某个类的所有成员锁起来同一时刻只能由一个线程访问

测试代码：业务类中既有同步代码也有非同步代码

public class SyncronizeMethod {

	public static void main(String[] args) {
		final Table2 tObj = new Table2();   // 共享对象
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				tObj.print(5);
				tObj.print2(5);
			}
		});
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run(){
				tObj.print(100);
				tObj.print2(100);
			}
		});
		
		t1.start();
		t2.start();
	}
}

class Table2 {
	synchronized public void print(int n){
		for(int i=1; i<= 5; i++){
			System.out.println(n*i);

//		try {
//			Thread.sleep(300);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
		
		}
	}
	
	 public  void print2(int n){
		 for(int i=1;i<=5;i++){
			 System.out.println(Thread.currentThread().getName() + "  " + n*i);
		 }
//		 
//		 try {
//			Thread.sleep(300);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
	 }
}


测试结果（可能结果之一）

5
10
15
20
25
Thread-0  5
Thread-0  10
100
200
300
400
500
Thread-1  100
Thread-1  200
Thread-1  300
Thread-1  400
Thread-1  500
Thread-0  15
Thread-0  20
Thread-0  25

以上输出只是本机大量测试结果中的一种，经过统计，使用syncronized修饰的代码输出始终没有出现穿插情况，但没有使用syncronized修饰的代码输出可能会出现不同线程交叉访问情况

4、类中有两个加锁方法在多线程调用时的表现

在生产者消费者模式中，假设有一个订单类，有两个方法生产订单、消费订单，都加上syncronized，生产者线程和消费者线程都公有一个订单实例，那么生产者线程和消费者线程能否并行访问订单呢？

测试代码：

public class OrderManager {

	// 容器最大值
	private static final int MAX_COUNT = 20;
	// 容器
	private Queue<Order> orderQueue = new LinkedList<Order>();
	private Random random = new Random();

	
	public static void main(String[] args) {
		OrderManager shareObj = new OrderManager();
		
		Thread produceThread = new Thread(new ProducerThread(shareObj));
//		Thread produceThread2 = new Thread(new ProducerThread(shareObj));
		produceThread.start();
//		produceThread2.start();
		
		Thread consumerThread = new Thread(new ConsumeThread(shareObj));
//		Thread consumerThread2 = new Thread(new ConsumeThread(shareObj));
		consumerThread.start();
//		consumerThread2.start();
	}
	
	
	public synchronized void addOrder(){
		for(int j=0;j<10;j++){
			try {
				System.out.println("生产者线程休眠2秒钟,第"+j+"次");
				Thread.sleep(2000);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			
			
			while(orderQueue.size() >= MAX_COUNT){
				try {
					System.out.println(Thread.currentThread().getName() + "队列已满,待会再生产");
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			int i = random.nextInt(1000);
			Order tempOrder = new Order(i,"order"+i);
			orderQueue.add(tempOrder);
			System.out.println(Thread.currentThread().getName() + "--produce order--" + tempOrder);
//			notifyAll();
		}
	}
	
	public synchronized void takeOrder(){
		for(int j=0;j<10;j++){
			try {
				System.out.println("消费者线程休眠2秒钟,第"+j+"次");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			while(orderQueue.size() < 1){
				try {
					System.out.println(Thread.currentThread().getName() + "队列已空,等待生产");
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			
			Order tempOrder = orderQueue.poll();
			System.out.println(Thread.currentThread().getName() + "--consume order--" + tempOrder);
			notifyAll();
		}
	}
}

class ProducerThread implements Runnable {
	
	private OrderManager orderManager;
	public  ProducerThread(OrderManager orderManager) {
		this.orderManager = orderManager;
	}

	@Override
	public void run() {
		while(true){
			orderManager.addOrder();
		}
	}
}

class ConsumeThread implements Runnable {
	private OrderManager orderManager;
	public  ConsumeThread(OrderManager orderManager) {
		this.orderManager = orderManager;
	}
	@Override
	public void run() {
		while(true){
			orderManager.takeOrder();
		}
	} 
}

输出结果（其中之一）： 

生产者线程休眠2秒钟,第0次
Thread-0--produce order--Order[orderId=858,orderName=order858]
生产者线程休眠2秒钟,第1次
Thread-0--produce order--Order[orderId=548,orderName=order548]
生产者线程休眠2秒钟,第2次
Thread-0--produce order--Order[orderId=703,orderName=order703]
生产者线程休眠2秒钟,第3次
Thread-0--produce order--Order[orderId=457,orderName=order457]
生产者线程休眠2秒钟,第4次
Thread-0--produce order--Order[orderId=530,orderName=order530]
生产者线程休眠2秒钟,第5次
Thread-0--produce order--Order[orderId=811,orderName=order811]
生产者线程休眠2秒钟,第6次
Thread-0--produce order--Order[orderId=552,orderName=order552]
生产者线程休眠2秒钟,第7次
Thread-0--produce order--Order[orderId=841,orderName=order841]
生产者线程休眠2秒钟,第8次
Thread-0--produce order--Order[orderId=100,orderName=order100]
生产者线程休眠2秒钟,第9次
Thread-0--produce order--Order[orderId=682,orderName=order682]
生产者线程休眠2秒钟,第0次
Thread-0--produce order--Order[orderId=950,orderName=order950]
生产者线程休眠2秒钟,第1次
Thread-0--produce order--Order[orderId=850,orderName=order850]
生产者线程休眠2秒钟,第2次
Thread-0--produce order--Order[orderId=370,orderName=order370]
生产者线程休眠2秒钟,第3次
Thread-0--produce order--Order[orderId=733,orderName=order733]
生产者线程休眠2秒钟,第4次
Thread-0--produce order--Order[orderId=774,orderName=order774]
生产者线程休眠2秒钟,第5次
Thread-0--produce order--Order[orderId=952,orderName=order952]
生产者线程休眠2秒钟,第6次
Thread-0--produce order--Order[orderId=878,orderName=order878]
生产者线程休眠2秒钟,第7次
Thread-0--produce order--Order[orderId=526,orderName=order526]
生产者线程休眠2秒钟,第8次
Thread-0--produce order--Order[orderId=648,orderName=order648]
生产者线程休眠2秒钟,第9次
Thread-0--produce order--Order[orderId=201,orderName=order201]
生产者线程休眠2秒钟,第0次
Thread-0队列已满,待会再生产
消费者线程休眠2秒钟,第0次
Thread-1--consume order--Order[orderId=858,orderName=order858]
消费者线程休眠2秒钟,第1次
Thread-1--consume order--Order[orderId=548,orderName=order548]
消费者线程休眠2秒钟,第2次
Thread-1--consume order--Order[orderId=703,orderName=order703]
消费者线程休眠2秒钟,第3次
Thread-1--consume order--Order[orderId=457,orderName=order457]
消费者线程休眠2秒钟,第4次
Thread-1--consume order--Order[orderId=530,orderName=order530]
消费者线程休眠2秒钟,第5次
Thread-1--consume order--Order[orderId=811,orderName=order811]
消费者线程休眠2秒钟,第6次
Thread-1--consume order--Order[orderId=552,orderName=order552]
消费者线程休眠2秒钟,第7次
Thread-1--consume order--Order[orderId=841,orderName=order841]
消费者线程休眠2秒钟,第8次
Thread-1--consume order--Order[orderId=100,orderName=order100]
消费者线程休眠2秒钟,第9次
Thread-1--consume order--Order[orderId=682,orderName=order682]
消费者线程休眠2秒钟,第0次

结果分析：生产者线程运行了两轮，中间没有打印消费者日志，直到队列充满，生产者线程中调用wait()释放了对象锁，消费者线程才获取到锁，开始消费

结论：对象锁范围覆盖了对象内所有syncronized代码块，在生产者和消费者公有一把锁情况下，二者无法达到并行运行，效率比较低，实际应用中应该采用独立的锁实现

例如LinkedBlockingQueue对于生产者端和消费者端分别采用了独立的锁来控制数据同步，可以在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能，而ArrayBlockingQueue是采用了共享锁实现。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值