Java线程的同步机制

并发

• 同一个对象被多个线程同时操作

• 现实生活中，我们会遇到"同一个资源，多个人都想使用"的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队，一个个来。

• 处理多线程问题，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用

队列和锁

• 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：
  • 一个线程持有锁会导致其他所有需要此锁的线程挂起；
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。

三大不安全案例

不安全买票

package com.cnblogs.thread;//不安全买票//会买到0 甚至负数public class UnsafeBuyTicket { public static void main(String[] args) {  BuyTicket buyTicket = new BuyTicket();  new Thread(buyTicket,"我").start();  new Thread(buyTicket,"你").start();  new Thread(buyTicket,"黄牛").start(); }}class BuyTicket implements Runnable{ private int TicketNum = 10; boolean flag = true; @Override public void run() {  while(flag){   try {    buy();   } catch (InterruptedException e) {    e.printStackTrace();   }  } } public void buy() throws InterruptedException {  if(TicketNum <= 0){   flag = false;   return;  }  Thread.sleep(1000);  System.out.println(Thread.currentThread().getName() + "买到了第" + TicketNum-- + "张票！"); }}/*黄牛买到了第10张票！你买到了第9张票！我买到了第8张票！黄牛买到了第7张票！你买到了第6张票！我买到了第5张票！黄牛买到了第4张票！你买到了第3张票！我买到了第2张票！黄牛买到了第1张票！你买到了第0张票！我买到了第-1张票！ */

不安全取钱

package com.cnblogs.thread;//不安全取钱public class UnsafeBank { public static void main(String[] args) {  Account account = new Account(200, "共同的基金");  Bank you = new Bank(account,100,"你");  Bank i = new Bank(account,200,"我");  you.start();  i.start(); }}//账户class Account{ int money; String name; public Account(int money, String name) {  this.money = money;  this.name = name; }}//银行 模拟取款class Bank extends Thread{ Account account;//账户 //取了多少钱 int drawingMoney; //现在还剩多少钱 int nowMoney; public Bank(Account account,int drawingMoney,String name){  super(name);  this.account = account;  this.drawingMoney = drawingMoney; } @Override public void run() {  if(account.money - drawingMoney < 0){   System.out.println("钱不够了，取不了钱");   return;  }  try {   Thread.sleep(1000);  } catch (InterruptedException e) {   e.printStackTrace();  }  //卡内余额 = 余额 - 你取的钱  account.money = account.money - drawingMoney;  //手里的钱  nowMoney = nowMoney + drawingMoney;  System.out.println(account.name + "余额为" + account.money);  //Thread.currentThread().getName() 和 this.getName() 一样的  System.out.println(this.getName() + "手里的钱" + nowMoney); }}/*共同的基金余额为100你手里的钱100共同的基金余额为-100我手里的钱200这里还多取了100块钱，银行血亏啊 */

不安全集合

package com.cnblogs.thread;import java.util.ArrayList;import java.util.List;//线程不安全集合public class UnsafeList { public static void main(String[] args) {  List<String> list = new ArrayList<>();  for (int i = 0; i < 10000; i++) {   new Thread(() -> {    list.add(Thread.currentThread().getName());   }).start();  }  try {   Thread.sleep(500);  } catch (InterruptedException e) {   e.printStackTrace();  }  System.out.println(list.size());  /*		9999   */ }}

同步方法及同步方法块

同步方法

• 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。

  • 同步方法：public synchronized void method(int args){}

• synchronized方法控制对"对象"的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

  • 缺陷：若将一个大的方法申明为synchronized会影响效率

同步方法弊端

• 方法里面需要修改的内容才需要锁，所得太多，浪费资源

同步块

• 同步块：synchronized（Obj）{}

• Obj称为同步监听器

  • Obj可以是任何对象，但是推荐使用共享资源作为同步监听器
  • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

• 同步监视器的执行过程

  1. 第一个线程访问，锁定同步监视器，执行其中代码
  2. 第二个线程访问，发现同步监视器被锁定，无法访问
  3. 第一个线程访问完毕，解锁同步监视器
  4. 第二个线程访问，发现同步监视器没锁，然后锁定并访问

不安全买票的解决方案

方案一：同步方法

package com.cnblogs.thread;//不安全买票 解决方案public class UnsafeBuyTicket { public static void main(String[] args) {  BuyTicket buyTicket = new BuyTicket();  new Thread(buyTicket,"我").start();  new Thread(buyTicket,"你").start();  new Thread(buyTicket,"黄牛").start(); }}class BuyTicket implements Runnable{ private int TicketNum = 10; boolean flag = true; @Override public void run() {  while(flag){   try {    buy();   } catch (InterruptedException e) {    e.printStackTrace();   }  } } //同步方法 public synchronized void buy() throws InterruptedException {  if(TicketNum <= 0){   flag = false;   return;  }  Thread.sleep(1000);  System.out.println(Thread.currentThread().getName() + "买到了第" + TicketNum-- + "张票！"); }}/*我买到了第10张票！黄牛买到了第9张票！黄牛买到了第8张票！黄牛买到了第7张票！你买到了第6张票！你买到了第5张票！你买到了第4张票！你买到了第3张票！黄牛买到了第2张票！我买到了第1张票！ */

方案二：同步代码块

package com.cnblogs.thread;//不安全买票 解决方案public class UnsafeBuyTicket { public static void main(String[] args) {  BuyTicket buyTicket = new BuyTicket();  new Thread(buyTicket,"我").start();  new Thread(buyTicket,"你").start();  new Thread(buyTicket,"黄牛").start(); }}class BuyTicket implements Runnable{ private int TicketNum = 10; boolean flag = true; Object o = new Object(); @Override public void run() {  while(flag){   //同步代码块   synchronized (o){    try {     buy();    } catch (InterruptedException e) {     e.printStackTrace();    }   }  } } public void buy() throws InterruptedException {  if(TicketNum <= 0){   flag = false;   return;  }  Thread.sleep(1000);  System.out.println(Thread.currentThread().getName() + "买到了第" + TicketNum-- + "张票！"); }}/*我买到了第10张票！你买到了第9张票！你买到了第8张票！黄牛买到了第7张票！黄牛买到了第6张票！你买到了第5张票！你买到了第4张票！你买到了第3张票！我买到了第2张票！我买到了第1张票！ */

不安全取钱的解决方案

package com.cnblogs.thread;//不安全取钱，解决方案public class UnsafeBank { public static void main(String[] args) {  Account account = new Account(200, "共同的基金");  Bank you = new Bank(account,100,"你");  Bank i = new Bank(account,200,"我");  you.start();  i.start(); }}//账户class Account{ int money; String name; public Account(int money, String name) {  this.money = money;  this.name = name; }}//银行 模拟取款class Bank extends Thread{ Account account;//账户 //取了多少钱 int drawingMoney; //现在还剩多少钱 int nowMoney; public Bank(Account account,int drawingMoney,String name){  super(name);  this.account = account;  this.drawingMoney = drawingMoney; } @Override public void run() {  //锁他的账户 锁的是变化的量，需要增删改的  synchronized (account){   if(account.money - drawingMoney < 0){    System.out.println("钱不够了，取不了钱");    return;   }   try {    Thread.sleep(1000);   } catch (InterruptedException e) {    e.printStackTrace();   }   //卡内余额 = 余额 - 你取的钱   account.money = account.money - drawingMoney;   //手里的钱   nowMoney = nowMoney + drawingMoney;   System.out.println(account.name + "余额为" + account.money);   //Thread.currentThread().getName() 和 this.getName() 一样的   System.out.println(this.getName() + "手里的钱" + nowMoney);  } }}/*共同的基金余额为100你手里的钱100钱不够了，取不了钱 */

不安全集合的解决方案

package com.cnblogs.thread;import java.util.ArrayList;import java.util.List;//线程不安全集合,解决方案public class UnsafeList { public static void main(String[] args) {  List<String> list = new ArrayList<>();  for (int i = 0; i < 10000; i++) {   new Thread(() -> {    synchronized (list){     list.add(Thread.currentThread().getName());    }   }).start();  }  try {   Thread.sleep(500);  } catch (InterruptedException e) {   e.printStackTrace();  }  System.out.println(list.size());  /*  10000   */ }}

死锁

• 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情形，某个同步块同时拥有"两个以上对象的锁"时，就可能会发生"死锁"的问题

死锁的案例

package com.cnblogs.thread;//死锁的案例public class DeadLock { public static void main(String[] args) {  Makeup g1 = new Makeup(0, "女一");  Makeup g2 = new Makeup(1, "女二");  g1.start();  g2.start();  //程序就会卡死，死锁 }}//口红class LipsLick{}//镜子class Mirror{}class Makeup extends Thread{ //用static保证资源只有一份 static LipsLick lipsLick = new LipsLick(); static Mirror mirror = new Mirror(); int choice;//选择 String name;//人 public Makeup(int choice , String name){  this.choice = choice;  this.name = name; } @Override public void run() {  //化妆  try {   makeup();  } catch (InterruptedException e) {   e.printStackTrace();  } } public void makeup() throws InterruptedException {  if(choice == 0){   synchronized (lipsLick){//获得口红的锁    System.out.println(this.name + "获得了口红的锁");    Thread.sleep(1000);    synchronized (mirror){//一秒后想获得镜子     System.out.println(this.name + "获得了镜子的锁");    }   }  }else{   synchronized (mirror){//获得口红的锁    System.out.println(this.name + "获得了镜子的锁");    Thread.sleep(2000);    synchronized (lipsLick){//两秒后想获......
原文转载：http://www.shaoqun.com/a/895423.html
跨境电商：https://www.ikjzd.com/
extra：https://www.ikjzd.com/w/1736
 
tradekey：https://www.ikjzd.com/w/1630
 
hemingway：https://www.ikjzd.com/w/2344
 
Java线程的同步机制并发同一个对象被多个线程同时操作现实生活中，我们会遇到"同一个资源，多个人都想使用"的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队，一个个来。处理多线程问题，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个
西藏日喀则定日县发生地震!：http://www.30bags.com/a/222733.html
西藏日喀则市谢通门县发生3.4级地震：http://www.30bags.com/a/222490.html
西藏日喀则特产 拉孜藏刀 -  ：http://www.30bags.com/a/407056.html
西藏日喀则饮茶的乐趣 -  ：http://www.30bags.com/a/406931.html
少妇口述:第一次尝试换妻游戏的美妙感受_第一次玩交换真实经历：http://lady.shaoqun.com/a/123609.html
公捡筷子时我故意把腿张开 他的手在课桌下揉捏着她：http://lady.shaoqun.com/a/247962.html
学长让我上课夹震动捧 少女思春上课偷偷夹笔杆：http://lady.shaoqun.com/a/247384.html
口述:少妇床技太好我偷情一次就上瘾少妇男人一次：http://www.30bags.com/m/a/249551.html
深圳上围艺术村有什么好玩的地方：http://www.30bags.com/a/523606.html
女生想被你睡，会做出哪三种暗示？主要是最后一个！：http://lady.shaoqun.com/a/433474.html
如何提高亚马逊产品点击率？：https://www.ikjzd.com/articles/146891
莫言的丰乳肥臀:纵欲背后的性欲、生殖崇拜、生育借籽生九子：http://lady.shaoqun.com/a/433476.html