Java线程安全问题以及解决方式，附上例子以及代码

线程安全问题

解决方法： 排队执行（通过加锁方式。）

1.同步代码块，线程同步：synchronized

格式： synchronized(锁对象){} 提示：任何对象都可以成为锁对象。

当不做任何处理的时候会出现线程不安全的情况，加入三个线程一个任务卖十张票代码如下：

package ceshi;

/**
 * 线程安全使用排对机制 synchronized 同步锁
 */
public class Demo4 {
    public static void main(String[] args) {
        //多态的形式创建
        Runnable runnable = new MyThread();
        //三个线程进行卖票
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }

    static public class MyThread implements Runnable{
        //假设有十张票
        private int num = 10;

        @Override
        public void run() {
            while (true){
                //如果票数大于0则可以卖
                if (num>0){
                    System.out.println("准备出票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    num--;
                    System.out.println(Thread.currentThread().getName()+"出票成功!还剩"+num);
                }else {
                    break;
                }
            }
        }
    }
}

就会出现以下这种情况

Thread-1出票成功!还剩-1
Thread-2出票成功!还剩-2
Thread-0出票成功!还剩-1

这就是线程不安全导致的，

现在我们对其进行同步使用synchronized就会排队进行卖票。

static public class MyThread implements Runnable{
    //假设有十张票
    private int num = 10;
    //同步锁
    private Object o = new Object();


    @Override
    public void run() {
        while (true){
            //如果票数大于0则可以卖
            synchronized (o){
                if (num>0){
                    System.out.println("准备出票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    num--;
                    System.out.println(Thread.currentThread().getName()+"出票成功!还剩"+num);
                }else {
                    break;
                }
            }
        }
    }
}

这样即可解决线程不安全问题，值得注意的是上锁的位置不可以如下图这样

public void run() {
    Object o = new Object();
    while (true){
        //如果票数大于0则可以卖

        synchronized (o){
            if (num>0){
                System.out.println("准备出票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num--;
                System.out.println(Thread.currentThread().getName()+"出票成功!还剩"+num);
            }else {
                break;
            }
        }
    }
}

或者下图：

public void run() {
    
    while (true){
        //如果票数大于0则可以卖
        Object o = new Object();
        synchronized (o){
            if (num>0){
                System.out.println("准备出票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num--;
                System.out.println(Thread.currentThread().getName()+"出票成功!还剩"+num);
            }else {
                break;
            }
        }
    }
}

这样相当于是锁在自己身上，并没有做到同步锁的要求，那么还是存在线程不安全的问题。

2.同步方法

如果不是静态的，synchronized的锁是this

如果是静态的，synchronized的锁是该类.class。

那么同步方法的实现代码如下：

主方法内容不变，实现接口的类里面将while判断的内容写成一个方法然后加上synchronized即可

static public class MyThread implements Runnable{
    //假设有十张票
    private int num = 10;
    //同步锁
    //private Object o = new Object();


    @Override
    public void run() {
        while (true){
            boolean flag = true;
            flag = calculater();
            if (!flag){
                break;
            }
        }
    }

    /**
     * 同步方法 synchronized
     * @return
     */
    public synchronized boolean calculater(){
        //如果票数大于0则可以卖
        if (num>0){
            System.out.println("准备出票");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"出票成功!还剩"+num);
            return true;
        }
        return false;
    }

}

当如果将在main方法内的线程变为三个线程各自的任务，则加与不加同步锁都互不影响，因为是各自完成各自的任务而非完成同一个任务。

//三个线程进行各自的卖票
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();

3.线程同步：Lock

同步代码块和同步方法都属于隐式锁，Lock为显式锁：

在接口实现类中创建Lock的对象：Lock lock = new ReentrantLock();然后在run方法里面进行上锁即可但是lock.lock()上锁之后需要lock.unlock()；解锁。

static public class MyThread implements Runnable{
    //假设有十张票
    private int num = 20;
    //显式锁 lock
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            if (num>0){
                System.out.println("准备出票");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num--;
                System.out.println(Thread.currentThread().getName()+"出票成功!还剩"+num);
            }else {
                break;
            }
            lock.unlock();
        }
    }
}

三个子线程式对同一个任务的时候有效。

公平锁与不公平锁

排队执行就是公平锁。

显式锁中 Lock lock = new ReentrantLock();

参数fair为true就为公平锁： Lock lock = new ReentrantLock(true);