线程同步

1. 多个线程访问同一个对象叫并发。

2. 线程同步就是：排队

3. 队列和 锁 解决线程的安全性问题

4. synchronized,当一个线程获得对象的排它锁，独占资源,其他线程必须等待，使用够释放锁即可。

5. 代码块锁可以锁任何地方。

   package Thread;
   ?
   public class UnsafyBuyTickets {
       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 tickets = 10;
       boolean falg = true;
       @Override
       public void run() {
      //买票
           while(falg){
               buy();
           }
   ?
       }
       private synchronized void buy(){
           //判断是否有票
           if (tickets<=0){
               falg = false;
               return;
           }
           //模拟代码延时
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println(Thread.currentThread().getName()+"拿到"+tickets--+"张票");
       }
   }

   package Thread;
   ?
   public class UnsafyBank {
       public static void main(String[] args) {
           Account account = new Account(2000000,"彩礼");
           Drawing you = new Drawing(account,1000000,"自己");
           Drawing wife = new Drawing(account,2000000,"妻子");
           you.start();
           wife.start();
       }
   }
   class Account {
     int money;
     String name;
     public Account(int money,String name){
         this.money = money;
         this.name = name;
     }
   }
   //模拟：银行取款
   class Drawing extends Thread{
       Account account;//账户
       int drawingMoney;//取了多少钱
       String name;
       //现在手里有多少钱
       int nowMoney;
       public Drawing(Account account,int drawingMoney,String name){
           super(name);
           this.account = account;
           this.drawingMoney = drawingMoney;
   ?
           this.nowMoney = nowMoney;
       }
   ?
       @Override
       public  void run() {
           //锁的对对象是变化的量，需要增删改操作的量。
           synchronized (account){
           if(account.money-drawingMoney<0){
               System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
           return;
           }
   ?
           //模拟延时
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           account.money = account.money-drawingMoney;
           nowMoney = nowMoney+drawingMoney;
           System.out.println(account.name+"余额为"+account.money);
           System.out.println(this.getName()+"手里的钱："+nowMoney);
       }
       }
   }

   package Thread;
   ?
   import java.util.ArrayList;
   import java.util.List;
   ?
   public class UnSafyList {
       public static void main(String[] args) {
           List<String> list = new ArrayList<String>();
   ?
               for (int i = 0; i < 10000; i++) {
   ?
                   new Thread(() -> {
                       synchronized (list) {
                       list.add(Thread.currentThread().getName());
                       }
                   }).start();
   ?
               }
           try {
               Thread.sleep(3000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println(list.size());
           }
   ?
   }
   ?

    

6.  

同步锁

原文：https://www.cnblogs.com/QIDream/p/14172632.html