线程同步 13

   线程同步： 

             处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，

             线程同步，其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面

             线程使用完毕，下一个线程在使用。

• 队列和锁：

                形成条件：队列+锁

                       1. 由于同一个进程多个线程共享同一块存储空间，在带来不方便的同时，也带来了访问

                           冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，

                           当一个线程获得对象的排它锁，独占资源，其它线程必须等待使用

                           后释放锁即可，存在一下问题：

                                         1. 一个线程持有锁会导致其它所有需要此锁的线程挂起。

                                         2. 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，

                                             引起性能问题。

                                         3. 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，

                                              引起性能问题。

       三大不安全案例:

 

package synchronized1;
//不安全的买票
//线程不安全，有负数，重复的票
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 ticketNums =10;
    boolean flag=true;//外部停止方式
    @Override
    public void run()
    {
        //买票
        while (flag)
        {
            try {
                buy();//调用buy方法
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
​
​
    }
    private void buy() throws Exception {
        //判断是否有票
        if (ticketNums<=0)
        {
            flag=false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}
---------------------------

package synchronized1;
//不安全的取钱，余额会变负数
//两个人去银行取钱账户
public class UnsafeBank
{
    public static void main(String[] args)
    {
        //账户
        Account account=new Account(100,"基金");
​
        Drawing youa=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"girlFriend");
​
        youa.start();
        girlFriend.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;
    //现在手里有多少钱
    int nowMoney;
    public Drawing(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(Thread.currentThread().getName()+"钱不够，取不了");
            return;//退出
        }
        try {
            Thread.sleep(1000);//sleep可以放大问题的发现性
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //银行卡余额=余额-你取得钱
        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);
        /*
        基金余额为：50
        你手里的钱50
        基金余额为：-50
        girlFriend手里的钱100
         */
    }
}

---------------------------

package synchronized1;
​
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(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(list.size());
    }
}

• 同步方法：

                   1.由于我们可以通过private关键字来保证数据对象只能被方法访问，

                      所以我们只需要针对方法提出一套机制，这套机制就是 synchronized

                      关键字，它包括两种用法：synchronized方法和synchronized块

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

                    2.synachronized方法控制”对象“的访问，每个对象对应一把锁，每个synchronized方法

                       都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行， 就独占

                       该锁直到方法返回才释放锁，后面被阻塞的线程才能获得这个锁。

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

//同步方法
package synchronized1;
//不安全的买票
​
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 ticketNums =10;
    boolean flag=true;//外部停止方式
    @Override
    public void run()
    {
        //买票
        while (flag)
        {
            try {
                buy();//调用buy方法
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
​
​
    }
    //synchronized同步方法,锁的是this
    private synchronized void buy() throws Exception {
        //判断是否有票
        if (ticketNums<=0)
        {
            flag=false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

• 同步块：

          synchronized(Obj){}

            Obj称之为同步监视器：

                                          1. obj可以是任何对象，但是建议使用共享资源作为同步监视器。

                                          2. 同步方法中无需指定监视器，因为同步方法的同步监视器就是this，

                                              就是这个对象本身，或者class[反射中讲解]

同步监视器的执行过程：1. 第一线程访问，锁定同步监视器，执行其中代码。

                                        2. 第二个线程访问，发现同步监视器被锁定，无法访问。

                                        3. 第一个线程访问完毕，解锁同步监视器。

                                        4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

 

package synchronized1;
//同步块
//两个人去银行取钱账户
public class UnsafeBank
{
    public static void main(String[] args)
    {
        //账户
        Account account=new Account(200,"基金");
​
        Drawing youa=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"girlFriend");
​
        youa.start();
        girlFriend.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;
    //现在手里有多少钱
    int nowMoney;
    public Drawing(Account account,int drawingMoney,String name)//写一个构造器传值
    {
        super(name);
        this.account=account;
        this.drawingMoney=drawingMoney;
​
    }
//取钱
    //synchronized默认锁的是this
    @Override
    public void run() {
      //判断有没有钱
        //锁的对象就是变化的量，需要增删改查的对象
        synchronized (account)//需要锁的是account，account是进行的增删改查
        {
            if (account.money-drawingMoney<0)
            {
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;//退出
            }
            try {
                Thread.sleep(1000);//sleep可以放大问题的发现性
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //银行卡余额=余额-你取得钱
            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);
        /*
       基金余额为：150
       你手里的钱50
       基金余额为：50
       girlFriend手里的钱100
         */
        }
​
    }
}
----------------------------

package synchronized1;
//同步块
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(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(list.size());//10000
    }
}

• JUC安全类型的集合：

package Runnable1;
​
import java.util.concurrent.CopyOnWriteArrayList;
​
//JUC安全类型的集合,人家写好了的，可以直接用
public class TestJUC
{
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();//<>约束，可加可不加
        for (int i = 0; i < 10000; i++)
        {
          new Thread(()->{
              list.add(Thread.currentThread().getName());
          }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
​
    }
}