线程安全问题：

简单来说，就是多个线程在操作同一个变量时引起的问题。

这里是用一个简单的例子说明一下：

以Runnable创建的线程为例:一个售票系统，count代表当前票数，卖出一张count--。

Runnable线程类：

public class Runnable_Exp implements Runnable{

    private int count = 50;

    @Override

    public void run() {

        while(true)

        if(count >= 0){

            System.out.println(Thread.currentThread().getName() +"现在的数："+count);

            count--;

        }else break;

    }

}

在main调用数个相同的Runnable线程：

Runnable_Exp rExp = new Runnable_Exp();

Thread trs1 = new Thread(rExp,"线程1");

Thread trs2 = new Thread(rExp,"线程2");

Thread trs3 = new Thread(rExp,"线程3");

Thread trs4 = new Thread(rExp,"线程4");

trs1.start();trs2.start();trs3.start();trs4.start();

运行：

我们会发现一个问题，票数会有相同的！

这就是线程安全的体现。此时我们就需要使用线程锁解决这个问题。

另外，我们之前学习的集合类中，有分线程安全与线程不安全的两类。

StringBuffer和Vector是线程安全的。

StringBuilder和ArrayList是线程不安全的。

在多线程中，我们不可以使用多个线程同时操作不安全的集合类

线程锁的使用：synchronized

Runnable中使用线程锁：

我们只需要修改一下Runnable线程类。

public class Runnable_Exp implements Runnable{

    private int count = 500;

    private Object lock = new Object();

    @Override

    public void run() {

        while(true)

            synchronized (lock) {

            if (count >= 0) {

                System.out.println(Thread.currentThread().getName() + "现在的数：" + count);

                count--;

            } else break;

        }

    }

}

解析：

添加一个线程锁对象，一般使用Object即可。

private Object lock = new Object();

这个Object对象lock是四个线程共享的（且这个lock一定是共用的！）可以自己尝试一下把锁放进run()中。

synchronized (lock)

当线程一运行到上面这一行的时候，线程一就会占用lock对象（相当于上锁了），直到线程一执行完synchronized语句块内的全部代码，lock对象就会取消占用。

若线程二运行到synchronized语句时，发现lock对象已经被占用了，则会等待，直到lock被取消占用。

有可能多个线程一起抢占。

效率会比较低。毕竟是你执行完再到我执行。无法同步执行。这就是所谓“抢占式”执行。

Thread中使用线程锁：

Thread线程类中：

public class Thread_Exp extends Thread {

    public Thread_Exp(){}

    public Thread_Exp(String name){

        super(name);

    }

    private static Object lock = new Object();

    private static int count = 100;

    public void run(){

        while(true)

            synchronized(lock){

                if (count >= 0) {

                    System.out.println(Thread.currentThread().getName() + "现在的数：" + count);

                    count--;

                } else break;

            }

    }

}

需要注意的是，这里的线程锁对象和count都需要设置为静态的！

Thread_Exp t1 = new Thread_Exp("线程1");

Thread_Exp t2 = new Thread_Exp("线程2");

Thread_Exp t3 = new Thread_Exp("线程3");

Thread_Exp t4 = new Thread_Exp("线程4");

t1.start();t2.start();t3.start();t4.start();

不创建Object对象可以实现相同的操作吗？

答案是可以的，我们可以不用创建Object类型的lock对象。

我们直接用synchronized(this)就可以了。

相当于检测当前对象是非被线程占用了（加锁）。

实例：

@Override

public void run() {

    synchronized (this){

        while(true)

            if (count >= 0) {

                System.out.println(Thread.currentThread().getName() + "现在的数：" + count);

                count--;

            } else break;

    }

}

我们还可以直接使用synchronized关键字描述一个方法，具体请看下文。

使用synchronized方法简化上述代码：

同步方法，顾名思义，就是自带线程锁的方法。

只需要在方法的返回值前面添加synchronized关键字即可。

原先的代码我们可以写成：

使得run()方法更加简洁。

@Override

public void run() {

    Count();

}

public synchronized void Count(){

    while(true)

    if (count >= 0) {

        System.out.println(Thread.currentThread().getName() + "现在的数：" + count);

        count--;

    } else break;

}

使用同步方法，这个方法体就会自动被加锁。

关于线程安全的方法：

上面我们说了StringBuffer方法是线程安全的，那我们是怎么知道的呢？

我们可以直接查看StringBuffer中方法的源代码。

例如attend方法：

@Override

@IntrinsicCandidate

public synchronized StringBuffer append(char c) {

    toStringCache = null;

    super.append(c);

    return this;

}

我们可以看到这个方法是synchronized方法。

大家可以自行去研究一下各种Java自带的方法，是否是线程安全的。

巴特西

【Java】学习路径47-线程锁synchronized