马士兵老师高并发编程基础入门

锁是指谁？

Object o = new Object();

		<p style="margin-left:0pt;">Synchronized(o);</p>
		</td>
	</tr></tbody></table><p style="margin-left:0pt;"><strong><span style="color:#0000ff;"><strong>我们一般认为</strong></span></strong><strong><span style="color:#0000ff;"><strong>Synchronized锁定的是这段代码块但事实上，Synchronized锁定的是锁这个对象。不仅如此Synchronized锁定的是heap内存中的这个对象而不是这个引用。</strong></span></strong></p>

一个例子

  1. /**
  2.  * 锁定某对象o，如果o的属性发生改变，不影响锁的使用
  3.  * 但是如果o变成另外一个对象，则锁定的对象发生改变
  4.  * 应该避免将锁定对象的引用变成另外的对象
  5.  * @author mashibing
  6.  */
  7. package yxxy.c_017;
  8.  
  9. import java.util.concurrent.TimeUnit;
  10.  
  11.  
  12. public class T {
  13. 	
  14. 	Object o = new Object();
  15.  
  16. 	void m() {
  17. 		synchronized(o) {
  18. 			while(true) {
  19. 				try {
  20. 					TimeUnit.SECONDS.sleep(1);
  21. 				} catch (InterruptedException e) {
  22. 					e.printStackTrace();
  23. 				}
  24. 				System.out.println(Thread.currentThread().getName());
  25. 				
  26. 				
  27. 			}
  28. 		}
  29. 	}
  30. 	
  31. 	public static void main(String[] args) {
  32. 		T t = new T();
  33. 		//启动第一个线程
  34. 		new Thread(t::m, "t1").start();
  35. 		
  36. 		try {
  37. 			TimeUnit.SECONDS.sleep(3);
  38. 		} catch (InterruptedException e) {
  39. 			e.printStackTrace();
  40. 		}
  41. 		//创建第二个线程
  42. 		Thread t2 = new Thread(t::m, "t2");
  43. 		
  44. 		t.o = new Object(); //锁对象发生改变，所以t2线程得以执行，如果注释掉这句话，线程2将永远得不到执行机会
  45. 		
  46. 		t2.start();
  47. 		
  48. 	}

Java的锁的本质就是内存对象上的一段信息，刚开始t2线程是抢不到那一把锁的因为被t1所占。但是后来o指向了另一个全新的对象这个在堆内存中的对象还没有被当做锁使用所以t2就拿它来当做自己的锁。见下图：

拓展：

由于锁的特性所以一般我们不要使用字符串常量来作为锁对象，这样会使得线程莫名的阻塞。看起来是两个字符串的引用但是他们指向的是同一段的内存。

重入锁

在同一个线程中同步代码块可以多次获得同一把锁。这种情况叫做可重入锁。当然还有一些引用计数的规则等等。这里重点强调的是调用，一旦是调用那么也就说明他们两个是在同一个方法中的。

Synchronized(m){

		<p style="margin-left:0pt;">Synchronized(m){</p>

		<p style="margin-left:0pt;">&nbsp;&nbsp;&nbsp;</p>

		<p style="margin-left:0pt;">}</p>

		<p style="margin-left:0pt;">}</p>
		</td>
	</tr></tbody></table><h3><a name="t2"></a><strong><strong><strong>ReentrantLock的特性</strong></strong></strong></h3>

·这是一种重入锁的实现。它有一个很大的特点就是必须的手动开启锁和释放锁。尤其是这个释放锁，不能忘记否则程序则会一直阻塞。与Synchronized不同的是Synchronized在遇到异常的时候就会释放锁但是ReentrantLock在异常下是不会释放锁的，因此经常在finally中进行锁的释放。

·locked = lock.tryLock(5, TimeUnit.SECONDS);尝试去获得锁，如果5秒还是没有获得到那么就会向下是执行。

·可以被打断的锁，如果一段代码被lock.lockInterruptibly(); 这个锁锁住，那么他能够被

t2.interrupt();这样的语句去手动打断。

·公平锁与不公平锁，通常来说Synchronized的锁是一种不公平的锁，而ReentrantLock可以实现公平锁。那什么是不公平呢？就是由于随机化的原因有的线程会由于运气不好久久得不到执行。公平就是使用了一种时间上的调度算法来使得每个线程的都能够得到公平的执行。

线程通信的底层


线程通信通常有两种，一种是读取共享的一段内存，还有一种就是线程之间互相通信。Java的线程通讯采用的是读取共享的一段内存。

Volatile关键字

这是一个案例，在上述代码不开volatile的时候new出来的那个线程把running从主内存中读取出来读到自己的缓冲区中并且以此为标签来执行while()中的代码块。而且一直执行下去在繁忙的情况下不会去读取主内存中的值，即使main线程对这个值做了修改。所以我们会看到while()中的代码一直被执行。

当volatile开启的时候，这两个线程之间也就变成了可见的了。具体原因就是在主内存的running的值被修改之后这时有一个线程会通知new出来的线程但缓冲区说你的running的值已经过期了，所以缓冲区的running的值会变成false随之while的执行结束。

值得一提的是在线程空闲的时候有可能会去主内存中读取值。

拓展：Volatile与Synchronized的联系与区别

Volatile只保证可见性，就是线程之间的变量是互相可见的，但是不能够保证原子性。

Synchronized，同时保证了原子性和可见性，因为Synchronized会将程序串行执行，当上一个程序执行完毕之后会将值写入到主内存中下一个线程来到时肯定会读取到这段内容。

这种感觉类似于数据库中的事务隔离级别。

AtomicXXX类型

因为++操作（当然也包含其他的系列操作）不是一个原子操作，所以在需要保证原子的++时可以通过上锁来解决问题，也可以通过以下的案例来解决：

  1. /**
  2.  * 解决同样的问题的更高效的方法，使用AtomXXX类
  3.  * AtomXXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性的
  4.  * @author mashibing
  5.  */
  6. package yxxy.c_015;
  7.  
  8. import java.util.ArrayList;
  9. import java.util.List;
  10. import java.util.concurrent.atomic.AtomicInteger;
  11.  
  12.  
  13. public class T {
  14. 	/*volatile*/ //int count = 0;
  15. 	
  16. 	AtomicInteger count = new AtomicInteger(0); 
  17.  
  18. 	/*synchronized*/ void m() { 
  19. 		for (int i = 0; i < 10000; i++)
  20. 			//if count.get() < 1000
  21. 			count.incrementAndGet(); //count++
  22. 	}
  23.  
  24. 	public static void main(String[] args) {
  25. 		T t = new T();
  26.  
  27. 		List<Thread> threads = new ArrayList<Thread>();
  28.  
  29. 		for (int i = 0; i < 10; i++) {
  30. 			threads.add(new Thread(t::m, "thread-" + i));
  31. 		}
  32.  
  33. 		threads.forEach((o) -> o.start());
  34.  
  35. 		threads.forEach((o) -> {
  36. 			try {
  37. 				o.join();
  38. 			} catch (InterruptedException e) {
  39. 				e.printStackTrace();
  40. 			}
  41. 		});
  42.  
  43. 		System.out.println(t.count);
  44.  
  45. 	}
  46.  
  47. }

一道淘宝面试题的演化（Volatile与门闩机制）

实现一个容器，提供两个方法，add，size。写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。

 

方案一：

正常的思维，单纯的判断容器的大小是无效的，因为线程之间是不可见的

  1. public class MyContainer1 {
  2.  
  3. 	List lists = new ArrayList();
  4.  
  5. 	public void add(Object o) {
  6. 		lists.add(o);
  7. 	}
  8.  
  9. 	public int size() {
  10. 		return lists.size();
  11. 	}
  12. 	
  13. 	public static void main(String[] args) {
  14. 		MyContainer1 c = new MyContainer1();
  15.  
  16. 		new Thread(() -> {
  17. 			for(int i=0; i<10; i++) {
  18. 				c.add(new Object());
  19. 				System.out.println("add " + i);
  20. 				
  21. 				try {
  22. 					TimeUnit.SECONDS.sleep(1);
  23. 				} catch (InterruptedException e) {
  24. 					e.printStackTrace();
  25. 				}
  26. 			}
  27. 		}, "t1").start();
  28. 		
  29. 		new Thread(() -> {
  30. 			while(true) {
  31. 				if(c.size() == 5) {
  32. 					break;
  33. 				}
  34. 			}
  35. 			System.out.println("t2 结束");
  36. 		}, "t2").start();
  37. 	}
  38. }

方案二：

在方案一的基础上加上volatile关键字，成功运行。因为两个线程之间是彼此可见的。

volatile List lists = new ArrayList();

方案三：

由于方案二的while的循环一直在监视所以十分的浪费CPU。因此我们将机制改为了wait()与notify()。也就是当t1检测到到达size到达5的时候叫醒正在沉睡的t2。但是t2、t1使用的是通一把锁而notify不会释放锁（当然它与notify起作用的前提是获得锁）。所以我们的最终方案是当t1叫醒t2的同时自己要wait()这样才保证了t2能够拿到锁然后t2执行完之后也要唤醒t1（由于这时候t2已经执行完毕了所以锁自然释放）。代码如下：

  1. public class MyContainer4 {
  2.  
  3. 	//添加volatile，使t2能够得到通知
  4. 	volatile List lists = new ArrayList();
  5.  
  6. 	public void add(Object o) {
  7. 		lists.add(o);
  8. 	}
  9.  
  10. 	public int size() {
  11. 		return lists.size();
  12. 	}
  13. 	
  14. 	public static void main(String[] args) {
  15. 		MyContainer4 c = new MyContainer4();
  16. 		
  17. 		final Object lock = new Object();
  18. 		
  19. 		new Thread(() -> {
  20. 			synchronized(lock) {
  21. 				System.out.println("t2启动");
  22. 				if(c.size() != 5) {
  23. 					try {
  24. 						lock.wait();
  25. 					} catch (InterruptedException e) {
  26. 						e.printStackTrace();
  27. 					}
  28. 				}
  29. 				System.out.println("t2 结束");
  30. 				//通知t1继续执行
  31. 				lock.notify();
  32. 			}
  33. 			
  34. 		}, "t2").start();
  35. 		
  36. 		try {
  37. 			TimeUnit.SECONDS.sleep(1);
  38. 		} catch (InterruptedException e1) {
  39. 			e1.printStackTrace();
  40. 		}
  41.  
  42. 		new Thread(() -> {
  43. 			System.out.println("t1启动");
  44. 			synchronized(lock) {
  45. 				for(int i=0; i<10; i++) {
  46. 					c.add(new Object());
  47. 					System.out.println("add " + i);
  48. 					
  49. 					if(c.size() == 5) {
  50. 						lock.notify();
  51. 						//释放锁，让t2得以执行
  52. 						try {
  53. 							lock.wait();
  54. 						} catch (InterruptedException e) {
  55. 							e.printStackTrace();
  56. 						}
  57. 					}
  58. 					
  59. 					try {
  60. 						TimeUnit.SECONDS.sleep(1);
  61. 					} catch (InterruptedException e) {
  62. 						e.printStackTrace();
  63. 					}
  64. 				}
  65. 			}
  66. 		}, "t1").start();
  67. 		
  68. 		
  69. 	}
  70. }

 

终极方案：

使用门闩机制

使用Latch（门闩）替代wait notify来进行通知

好处是通信方式简单，同时也可以指定等待时间

使用await和countdown方法替代wait和notify

CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行

当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了

这时应该考虑countdownlatch/cyclicbarrier/semaphore

@author mashibing

首先new一个门闩CountDownLatch latch = new CountDownLatch(1);里面有一个参数，同时他有一个方法就是latch.await();，它会插在代码之间阻拦代码的执行。同时latch.countDown();方法会减少门闩的数量当门闩的数量减少为0的时候这时门会自动打开这时候latch.await();会向下执行。整个过程不涉及锁的机制，高效得实现了线程之间的通信。

  1. public class MyContainer5 {
  2.  
  3. 	// 添加volatile，使t2能够得到通知
  4. 	volatile List lists = new ArrayList();
  5.  
  6. 	public void add(Object o) {
  7. 		lists.add(o);
  8. 	}
  9.  
  10. 	public int size() {
  11. 		return lists.size();
  12. 	}
  13.  
  14. 	public static void main(String[] args) {
  15. 		MyContainer5 c = new MyContainer5();
  16.  
  17. 		CountDownLatch latch = new CountDownLatch(1);
  18.  
  19. 		new Thread(() -> {
  20. 			System.out.println("t2启动");
  21. 			if (c.size() != 5) {
  22. 				try {
  23. 					latch.await();
  24. 					
  25. 					//也可以指定等待时间
  26. 					//latch.await(5000, TimeUnit.MILLISECONDS);
  27. 				} catch (InterruptedException e) {
  28. 					e.printStackTrace();
  29. 				}
  30. 			}
  31. 			System.out.println("t2 结束");
  32.  
  33. 		}, "t2").start();
  34.  
  35. 		try {
  36. 			TimeUnit.SECONDS.sleep(1);
  37. 		} catch (InterruptedException e1) {
  38. 			e1.printStackTrace();
  39. 		}
  40.  
  41. 		new Thread(() -> {
  42. 			System.out.println("t1启动");
  43. 			for (int i = 0; i < 10; i++) {
  44. 				c.add(new Object());
  45. 				System.out.println("add " + i);
  46.  
  47. 				if (c.size() == 5) {
  48. 					// 打开门闩，让t2得以执行
  49. 					latch.countDown();
  50. 				}
  51.  
  52. 				try {
  53. 					TimeUnit.SECONDS.sleep(1);
  54. 				} catch (InterruptedException e) {
  55. 					e.printStackTrace();
  56. 				}
  57. 			}
  58.  
  59. 		}, "t1").start();
  60.  
  61. 	}
  62. }

最后感谢马老师，一个专心做教育的老师。

原文地址：https://blog.csdn.net/qq_34993631/article/details/82425052
posted @ 2018-11-06 09:37  星朝  阅读(777)  评论(0)  编辑  收藏  举报