线程——线程安全问题

【1】出现问题：

（1）出现了两个10张票或者3个10张票：

（2）出现了0，-1，-2这样的数据：

上面的代码出现问题：出现了重票，错票---》线程安全引起的

原因：多个线程，在争抢资源的过程中，导致共享的资源出现问题，一个线程还没执行完，另一个线程就参与进来了，开始争抢。

解决：

在我的程序中，加入”锁“---》加同步---》同步监视器

加锁的方式

【1】方法1：同步代码块

是以代码块的形式把这个锁加进来的

package com.wxj.test03;

public class BuyTicketThread implements Runnable{
    int Ticket = 10;
    public BuyTicketThread(String name){
        super();
        /*你看人父构造有参数么，硬传，线程的名字是线程启动的时候系统给的，你不能自定义*/
    }
    @Override
    public void run() {
        synchronized (this){//把具有安全隐患的代码锁住即可，如果锁多了就会效率低--》这个this就是这把锁
            for(int i=1;i<=100;i++){
                if(Ticket>0){System.out.println("我在"+Thread.currentThread().getName()+"抢到了第"+ Ticket-- +"张车票");}
            }
        }
    }
}

【2】同步代码块演示2：

如果代码中创建了多个对象的话，那么必须公用一把锁，不能一人一把，那样也会导致输出错误。

package com.wxj.test02;

public class BuyTicketThread extends Thread {
    //每个窗口都是一个线程对象，每个对象执行的代码都要放到重写的run方法中
    static int Ticket = 10;//多个窗口共享10张票

    public BuyTicketThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        //每个窗口后面有100人在抢票
        for (int i = 1; i <= 100; i++) {
            synchronized (BuyTicketThread.class) {//锁必须多个线程公用一把锁
                if (Ticket > 0) {
                    System.out.println("我在" + this.getName() + "抢到了第" + Ticket-- + "张车票");
                }
            }

        }
    }
}

这【2】中如果像【1】中那样在synchronized中设置为this的话，因为在【2】中main函数中创建了3个对象，用this的话相当于用了三把锁，但是加锁的话必须只加一把锁，换成类的字节码信息。

package com.wxj.test02;

public class BuyTicketThread extends Thread {
    //每个窗口都是一个线程对象，每个对象执行的代码都要放到重写的run方法中
    static int Ticket = 10;//多个窗口共享10张票

    public BuyTicketThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        //每个窗口后面有100人在抢票
        for (int i = 1; i <= 100; i++) {
            synchronized (BuyTicketThread.class) {//锁必须多个线程公用一把锁
                if (Ticket > 0) {
                    System.out.println("我在" + this.getName() + "抢到了第" + Ticket-- + "张车票");
                }
            }

        }
    }
}

【3】锁（同步监视器）的总结：

总结1：认识同步监视器（锁）-----synchronized（同步监视器）{}

（1）必须是引用数据类型，不能是基本数据类型

（2）也可以创建一个专门的同步监视器，没有任何业务含义

（创建的Object对象，但是必须保证独一份，要加static）

（3）一般使用共享资源做同步监视器即可

（4）在同步代码块中不能改变同步监视器对象的引用

（5）尽量不要String和包装类Integer做同步监视器

（6）建议使用final修饰同步监视器

总结2：同步代码块的执行过程

（1）第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码

（2）第一个线程执行过程中，发生了线程切换(阻塞 就绪)，第一个线程失去了cpu，但是没有开锁open

（3）第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态

（4）第一个线程再次获取CPU,接着执行后续的代码，同步代码块执行完毕，释放锁open

（5）第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，拿到锁并且上锁，由阻塞状态进入战绪状态，再进入运行状态，重复第一个线程的处理过程(加锁)

强调:同步代码块中能发生CPU的切换吗? 能!!!但是后续的被执行的线程也无法执行同步代码块(因为锁仍旧close)

总结3：其他

【4】方法2：同步方法

思想喝同步代码块类似，将同步代码块的部分拿出来当一个新的方法

public class BuyTicketThread extends Thread {
    //每个窗口都是一个线程对象，每个对象执行的代码都要放到重写的run方法中
    static int Ticket = 10;//多个窗口共享10张票

    public BuyTicketThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        //每个窗口后面有100人在抢票
        for (int i = 1; i <= 100; i++) {

                if (Ticket > 0) {

                }
            }

        }
    public static  synchronized void buyTicket(){//锁住的同步监视器： ButTicketThread.class 
        System.out.println("我在" + Thread.currentThread().getName() + "抢到了第" + Ticket-- + "张车票");
    }
    }

public class BuyTicketThread implements Runnable{
    int Ticket = 10;
    public BuyTicketThread(String name){
        super();
        /*你看人父构造有参数么，硬传，线程的名字是线程启动的时候系统给的，你不能自定义*/
    }
    @Override
    public void run() {
            for(int i=1;i<=100;i++){
            buyTicket();
            }
        }


    public synchronized void buyTicket(){//锁住的是this
        if(Ticket>0){System.out.println("我在"+Thread.currentThread().getName()+"抢到了第"+ Ticket-- +"张车票");}
    }
    }

总结：

总结1：

总结2：

（1）不要将run（）定义为同步方法 因为那样锁住的东西太多了，效率太低

（2）非静态同步方法的同步监视器是this

静态同步方法的同步监视器是 类名.class 字节码信息对象

（3）同步代码块的效率要高于同步方法

原因:同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部

（4）同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法，同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块

【5】方法3：Lock锁引入：

一共有三步：拿来一把锁，打开锁，关闭锁。

package com.wxj.test03;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BuyTicketThread implements Runnable{
    int Ticket = 10;
    Lock lock = new ReentrantLock();//拿一把锁（Lock底层是接口，创建对象的话要创建他的实现类），他可以使用不同的实现类，所以他的扩展性就好
    public BuyTicketThread(String name){
        super();
        /*你看人父构造有参数么，硬传，线程的名字是线程启动的时候系统给的，你不能自定义*/
    }
    @Override
    public void run() {

            for(int i=1;i<=100;i++){
                lock.lock();//打开锁
                try{
                    if(Ticket>0){System.out.println("我在"+Thread.currentThread().getName()+"抢到了第"+ Ticket-- +"张车票");}
                }catch (Exception ex){
                    ex.printStackTrace();
                }finally {
                    lock.unlock();//关闭锁
            }
        }
    }
}

Lock和synchronized的区别： （Lock底层是接口）

1.Lock是显式锁(手动开启和关闭锁，别忘记关闭锁)，synchronized是隐式锁

2.Lock只有代码块锁，synchronized有代码块锁和方法锁

3.使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)

优先使用顺序：

Lock----同步代码块----同步方法

【6】线程同步的优缺点：

（1）对比：

线程安全，效率低

线程不安全，效率高

（2）可能造成死锁：

死锁（解决方法：避免同步操作的嵌套）

->不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

->出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续