java线程同步的安全问题解决

综上可知，线程安全问题产生的根本原因是共享数据存在被并发修改的可能，即一个线程读取时，允许另一个线程修改。
模拟售票台卖票查看线程安全问题

public class RunImpl implements Runnable{
    //共享资源....（票）
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            if(ticket>0){
                try {
                    // 提高线程安全问题出现的概率，不用此方法多运行几次也能发现多线程安全问题
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("当前售票厅"+Thread.currentThread().getName()+ "正在卖"+ticket+"张飘");
                ticket--;
            }
        }
    }
}

三个线程中能够看到会出售同样的票 还会出现-1 -0的票，

public class RunMain {
    public static void main(String[] args) {
        Runnable run = new RunImpl();
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);
        t1.start();
        t2.start();
        t3.start();
    }
}

解决线程安全问题java引入了同步机制
同步保证了只能有一个线程 在同步中执行共享数据，保证了安全 ，缺点程序会不断的判断锁，获取锁，施放锁，
1、同步代码块 // 同步代码块会出现阻塞状态
2、同步方法
3、锁机制

一、同步代码块
synchronized 关键字锁对象。
使用锁对象（同步锁，对象锁，对象监视器）多线程一起抢夺CPU的执行权，谁抢到了就执行run方法 当遇见synchronized代码块，这时候就会检查同步代码块是否有锁对象，发现有锁对象就会获取到锁对象进入到同步中执行， 发现没有就会进入到阻塞状态等待归还锁对象，

synchronized(锁对象){
共享资源代码块；
}

public class RunImpl implements Runnable{
    //共享资源....（票）
    private int ticket = 100;
    Object obj = new Object();//锁对象可以是任意类型
    @Override
    public void run() {
        while (true){
            synchronized(obj){
                if(ticket>0){
                    try {
                        // 提高线程安全问题出现的概率，不用此方法多运行几次也能发现多线程安全问题
                        Thread.sleep(4000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("当前售票厅"+Thread.currentThread().getName()+ "正在卖第"+ticket+"张票");
                    this.ticket--;
                }
            }
        }
    }
}

二、同步方法
同步方法使用的锁对象是实现类对象（this）
1、把访问共享数据的代码抽取出来放在一个方法中
2、在方法中添加一个synchronized修饰符

public class RunImpl implements Runnable{
    //共享资源....（票）
    private int ticket = 100;
    @Override
    public void run() {

        while (true){
            synMtehon();
        }
    }
    //定义同步方法；
    public synchronized void synMtehon(){
        //共享资源代码块
        if(ticket>0){
            try {
                // 提高线程安全问题出现的概率，不用此方法多运行几次也能发现多线程安全问题
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("当前售票厅"+Thread.currentThread().getName()+ "正在卖第"+ticket+"张票");
            this.ticket--;
        }
    }

}

三 、静态同步方法
1、静态同步的锁对象是类本身 --class文件对象
public static synchronized void synMtehon(){
//共享资源代码块
if(ticket>0){
try {
// 提高线程安全问题出现的概率，不用此方法多运行几次也能发现多线程安全问题
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“当前售票厅”+Thread.currentThread().getName()+ “正在卖第”+ticket+“张票”);
this.ticket–;
}
}

}

四、lock 锁；
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。
lock接口中常用的两个方法  lock unlock
ReentrantLock 实现了lock接口,
1、在成员位置创建一个ReentrantLock对象
2、在可能会出现安全问题的代码钱前调用lock接口中的lock（）方法获取锁 
3、在可能会出现安全问题的代码钱前调后lock接口中的unlock（）方法的释放锁

import java.util.concurrent.locks.ReentrantLock;

public class RunImpl implements Runnable{
//共享资源…（票）
private int ticket = 100;
ReentrantLock l = new ReentrantLock();
@Override
public void run() {
while (true){
l.lock();
if(ticket>0){
try {
// 提高线程安全问题出现的概率，不用此方法多运行几次也能发现多线程安全问题
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“当前售票厅”+Thread.currentThread().getName()+ “正在卖第”+ticket+“张票”);
this.ticket–;
}
l.unlock();
}
}
//同步方法；
//共享资源代码块
}

使用异常  lock方法更好的方法

import java.util.concurrent.locks.ReentrantLock;

public class RunImpl implements Runnable {
//共享资源…（票）
private int ticket = 100;
ReentrantLock l = new ReentrantLock();

@Override
public void run() {
    while (true) {
        l.lock();
        if (ticket > 0) {
            try {
                // 提高线程安全问题出现的概率，不用此方法多运行几次也能发现多线程安全问题
                Thread.sleep(100);
                System.out.println("当前售票厅" + Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                this.ticket--;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                l.unlock();
            }
        }
    }
}

}