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

线程安全问题：

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

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

以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自带的方法，是否是线程安全的。