线程安全的解决

线程安全问题

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题.要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题

比如说卖票,如果三个窗口就是三个线程同时卖100张票,如果同时迈出了一眼的票,就是出现了线程安全的问题
我们来模拟一下
我们创建一个卖票的线程

package com.thread;

/**
 * @author 邓亚非
 */
public class ThreadSafe implements Runnable{
    private  int tickets=100;


    @Override
    public void run() {
        while (true){
            if (tickets>0){
                System.out.println(Thread.currentThread().getName()+"正在卖第"+tickets--+"张票");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

创建测试类

package com.thread;

/**
 * @author 邓亚非
 */
public class TestTheadSafe {
    public static void main(String[] args) {
        ThreadSafe threadSafe=new ThreadSafe();
        Thread t1=new Thread(threadSafe);
        Thread t2=new Thread(threadSafe);
        Thread t3=new Thread(threadSafe);
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果,出现了同时卖97张票的现象,也就是出现了线程安全的问题

解决线程安全的方式

1:同步代码块

把共享资源的代码块存放在一个synchornized锁内,这个关键字能起到排斥作用,一个线程在执行,其他的线程来抢资源会被它排斥,表示只对这个块的资源进行互斥访问
同步锁:
锁住的对象可以是任意类型
多个线程访问资源,要使用同一把锁,只有这样才能判断是否执行同步代码

package com.thread;

/**
 * @author 邓亚非
 * 注意:
 * 1.通过代码块中的锁对象,可以使用任意的对象
 * 2.但是必须保证多个线程使用的锁对象是同一个
 * 3.锁对象作用:把同步代码块锁住,只让一个线程在同步代码块中执行
 */
public class ThreadSafe implements Runnable {
    private int tickets = 100;

    private Object object = new Object();

    @Override
    public void run() {
        synchronized (object) {
            while (true) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(0);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets-- + "张票");
                }
            }
        }
    }
}

package com.thread;

/**
 * @author 邓亚非
 */
public class TestTheadSafe {
    public static void main(String[] args) {
        ThreadSafe threadSafe=new ThreadSafe();
        Thread t1=new Thread(threadSafe);
        Thread t2=new Thread(threadSafe);
        Thread t3=new Thread(threadSafe);
        t1.start();
        t2.start();
        t3.start();
    }
}

同步技术原理:
我们在加了锁以后,就起到了一个监视器的作用,这个叫锁对象也叫同步锁,t1在执行run方法的时候,会先去判断同步代码块有没有锁对象,锁里面有没有被锁得对象,如果有锁对象就会进入到同步代码块,执行同步代码块的代码,只有执行完同步代码块才会释放锁,那么在t1执行的时候,这个时候t2得到了cpu的执行权然后t2执行run()方法,在进入同步代码块的时候,会先判断同步代码块有没有锁对象,这个时候是没有锁对象的,然后会迫使t2进入到阻塞状态,等待t1执行完释放锁对象之后才会执行同步代码块中的代码,所以这么做就不会出现线程安全问题,不会出现结构线程同时抢占共享资源的事情
2:同步方法

package com.thread;

/**
 * @author 邓亚非
 * 注意:
 * 1.通过代码块中的锁对象,可以使用任意的对象
 * 2.但是必须保证多个线程使用的锁对象是同一个
 * 3.锁对象作用:把同步代码块锁住,只让一个线程在同步代码块中执行
 */
public class ThreadSafe implements Runnable {
    private int tickets = 100;

    private Object object = new Object();

    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sellTickets();
    }
    /**
     * 同步方法加了同步锁
     */
    public synchronized void sellTickets(){
        while (true) {
            if (tickets > 0) {
                try {
                    Thread.sleep(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets-- + "张票");
            }
        }
    }
}

这个时候在方法上面加了这个关键字,这个时候锁对象就是这个方法的调用者就是this,它是一个隐含的锁对象
非静态同步方法:
没有在static关键字的方法,锁对象是当前调用方法的对象,也就是this
静态同步方法:
加了static关键字的方法,锁对象是当前类的.class对象
3:lock锁解决

lock锁也称同步锁,lock锁实现类的对象分别先后调用
java.util.concurrent.locks.Lock接口
public void lock()
public void unlock()

lock()方法必须放在可能方式线程安全的代码前面
unlock方法必须放在可能方式线程安全代码的后面

package com.thread;

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

/**
 * @author 邓亚非
 * 注意:
 * 1.通过代码块中的锁对象,可以使用任意的对象
 * 2.但是必须保证多个线程使用的锁对象是同一个
 * 3.锁对象作用:把同步代码块锁住,只让一个线程在同步代码块中执行
 */
public class ThreadSafe implements Runnable {
    Lock reentrantLock = new ReentrantLock();
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                reentrantLock.lock();
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets-- + "张票");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }

            }
        }
    }
}

如果有try-catch语句unlock方法要放在finally后面而且是第一行