Java的线程安全的问题

先看一下，下面的一个买票代码

package cn.itcast.day02.demo08;
public class Runnableimpl implements Runnable{
    private int tickets=100;
    @Override
    public void run() {
        while(true){
            if(tickets>0){
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"---->正在卖第"+tickets+"张票");
                tickets--;
            }
        }

    }
}

package cn.itcast.day02.demo08;
public class maindemo {
    public static void main(String[] args) {
        Runnableimpl r=new Runnableimpl();
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        Thread t3=new Thread(r);
        t1.start();t2.start();t3.start();
    }
}

Thread-0---->正在卖第100张票
Thread-2---->正在卖第100张票
Thread-1---->正在卖第100张票
Thread-1---->正在卖第97张票
Thread-0---->正在卖第97张票
...
Thread-0---->正在卖第2张票
Thread-2---->正在卖第1张票
Thread-1---->正在卖第1张票
Thread-0---->正在卖第-1张票

问题产生的原因：
线程安全问题是不能产生的，我们可以让一个线程在访问共享数据的时候，无论是否失去了cpu的执行权，让其他的线程只能等待，等待当前线程买完票，其他线程在进行买票。【保证一个线程再买票】

线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解绝。
为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。有三种方式完成同步操作：

• 同步代码块
• 同步方法
• 锁机制

同步代码块

买票出现了线程安全的问题，卖出了不存在的票和重复的票
【第一种方案】:使用同步代码块
格式:
synchronized(锁对象){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}

注意:
    1.通过代码块中的【锁对象】,可以使用任意的对象
    2.但是必须保证多个线程使用的【锁对象】是【同一个】
    3.锁对象作用:
        把同步代码块锁住,只让【一个线程】在同步代码块中执行

package cn.itcast.day02.demo08;
public class Runnableimpl implements Runnable{
   //定义一个多线程共享的票源
    private int tickets=100;
    //创建一个锁对象
    Object ob=new Object();
    @Override
    public void run() {
        while(true){
           synchronized (ob){
               if(tickets>0){
                   //提高安全问题出现的概率，让程序睡眠
                   try {
                       Thread.sleep(100);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName()+"---->正在卖第"+tickets+"张票");
                   tickets--;
               }
           }
        }
    }
}

同步技术原理：
使用一个锁对象，这个锁对象叫同步锁，也叫做对象监视器。同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步，处于【阻塞等待】状态。效率会变低，要不断地---->【判断锁】---->【获取锁】---->【释放锁】

同步方法

【第二种方案】:使用同步方法
使用步骤:
1.把访问了共享数据的代码抽取出来,放到一个方法中
2.在方法上添加synchronized修饰符

格式:定义方法的格式
修饰符 synchronized 返回值类型 方法名(参数列表){
    可能会出现线程安全问题的代码(访问了共享数据的代码)
}

package cn.itcast.day02.demo08;
public class Runnableimpl implements Runnable{
   //定义一个多线程共享的票源
    private int tickets=100;
    //创建一个锁对象
   // Object ob=new Object();
    @Override
    public void run() {
        while(true){
             payticket();
        }
    }
   //同步方法
    public synchronized void payticket(){

        if(tickets>0){
            //提高安全问题出现的概率，让程序睡眠
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"---->正在卖第"+tickets+"张票");
            tickets--;
        }
    }
}

##静态同步方法
锁对象是谁?
不能是this
this是创建对象之后产生的,静态方法优先于对象
静态方法的锁对象是本类的class属性–>class文件对象(反射)

package cn.itcast.day02.demo08;
public class Runnableimpl implements Runnable{
   //定义一个多线程共享的票源
    private static int tickets=100;
    //创建一个锁对象
   // Object ob=new Object();
    @Override
    public void run() {
        while(true){
            Staticpayticket();
        }
    }
    public static synchronized void Staticpayticket(){
        if(tickets>0){
            //提高安全问题出现的概率，让程序睡眠
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"---->正在卖第"+tickets+"张票");
            tickets--;
        }
    }
}

或者

package cn.itcast.day02.demo08;
public class Runnableimpl implements Runnable{
   //定义一个多线程共享的票源
    private static int tickets=100;
    //创建一个锁对象
   // Object ob=new Object();
    @Override
    public void run() {
        while(true){
            Staticpayticket();
        }
    }
    public static /*synchronized*/ void Staticpayticket() {
        synchronized (Runnableimpl.class) {
            if (tickets > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "---->正在卖第" + tickets + "张票");
                tickets--;
            }
        }
    }
}

锁机制

【第三种方案】:使用Lock锁
java.util.concurrent.locks.Lock接口
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
Lock接口中的方法:
void lock()获取锁。
void unlock() 释放锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口

使用步骤:
    1.在成员位置创建一个ReentrantLock对象
    2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
    3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

package cn.itcast.day02.demo08;

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

public class Runnableimpl implements Runnable{
   //定义一个多线程共享的票源
    private static int tickets=100;
    //创建一个锁对象
   // Object ob=new Object();
    Lock l=new ReentrantLock();
    @Override
    public void run() {
        while(true){
            l.lock();
            //共享代码
            if (tickets > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(Thread.currentThread().getName() + "---->正在卖第" + tickets + "张票");
                    tickets--;
                    l.unlock();
                }

            }


        }
    }
   
}