【Java并发学习】之线程的同步
前言
在前面一个小节中，我们学习了线程的概念以及在Java中创建任务的方式，并且将任务委托给对应的线程进行执行，本小节我们主要来学习线程之间的关系之一的同步，包含临界区、临界资源、线程同步的两种主要方法
线程的关系
从广义上来讲，线程之间有三种关系
- 没有关系：多个线程之间相互独立，既不竞争资源，也没有任何的合作关系，只是各自完成自己的任务
- 竞争关系：两个及以上的线程之间存在对某个或者某些资源的竞争
- 合作关系：两个及以上的线程共同合作，完成某项任务
临界区及临界资源
学习线程之间的同步，必不可少会接触到临界区以及临界资源这两个概念，而线程之间存在竞争关系本质上就是由于临界资源的存在，而解决的方式就是使得多个线程之间能够序列化访问临界资源
- 临界资源：临界资源指的是程序中会被多个线程共享的某个或者某些资源，可以是软件资源也可以是硬件资源，比如某个变量，某个数组，某个容器，打印机等等
- 临界区：临界区指的是访问临界资源的代码，同步操作的主要对象
线程的同步
线程同步是一个非常重要的概念，也是在并发编程中比不可少的关键操作，需要进行同步的本质原因在于，资源的有限，由于资源的数量少于线程的数量，于是线程在访问这些资源的时候需要进行同步处理，如果没有进行同步处理，或者同步处理时不恰当，轻则会导致数据出错，重则会出现严重的并发问题
首先我们来看下没有进行同步处理所带来的后果
情景：假设现在一个公园有三个门，我们需要统计某个时刻公园里的人的总数，由于三个门的统计方式一样，所以我们可以直接采用相同的三个线程来进行统计即可
/**
* 公园类，包含一个计数器，进入以及离开记录的操作
*/
class Park{
private static int counter = 0;
public void enter(){
counter++;
}
public void leave(){
counter--;
}
public int getCounter(){
return counter;
}
}
/**
* 公园的进出登记
*/
class DoorWatcher implements Runnable{
private Park park;
public DoorWatcher(Park park) {
this.park = park;
}
@Override
public void run() {
while (true){
park.enter(); // 进入公园
try {
Thread.sleep(1000);// 模式人留在公园中的操作
} catch (InterruptedException e) {
e.printStackTrace();
}
park.leave(); // 离开公园
}
}
}
从上面的操作可以看出，如果程序正常执行，那么每个时刻公园中的人数应该是总体上保持稳定的，毕竟每个人进入公园之后会离开公园
对应的测试类如下
public static void main(String[] args) throws InterruptedException {
Park park = new Park();
// 模拟公园的门的计数器
int doorNumber = 3;
Runnable jobs[] = new Runnable[doorNumber];
for (int i = 0; i < doorNumber; i++){
jobs[i] = new DoorWatcher(park);
}
// 执行对应的任务
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < doorNumber; i++) {
executor.submit(jobs[i]);
}
// 定时检查公园中的人数
while (true){
System.out.println("current number in the park is " + park.getCounter());
Thread.sleep(3000); // 每隔三秒检查一次
}
}
测试的可能结果
current number in the park is 0
current number in the park is 2
current number in the park is 2
current number in the park is 2
current number in the park is 3
current number in the park is 3
....
current number in the park is 2
current number in the park is 1
current number in the park is 1
....
执行测试代码之后，可能你会发现实际上程序的运行并不是想象中那样，而且不同次的运行可能结果还不一样，出问题的地方在于counter++以及counter-- 这两个操作，这两个操作在Java中并不是原子操作，关于原子操作，我们会在后面进行深入的学习，这两个操作都包含了取出数据，修改数据，写入数据这三个步骤，而如果没有进行同步处理，则在进行其中任何一个步骤的时候，当前线程可能被挂起，其他线程对counter进行修改，从而导致了数据的不一致，类似的情况还有很多，这里就不进行具体的分析。
由于出现问题的部分是对变量counter的操作，也就是说，这里的counter就是我们所说到的临界资源，而对应的enter以及leave方法则是对应的临界区，或者更详细的说counter++,counter--就是我们所指的临界区
解决线程同步问题的方法从广义上来讲只有一个，那就是序列化访问临界资源，也就是说，同一时刻只允许一个线程来对临界资源进行操作，这种方式有效地解决了同步问题，而具体的操作就是对临界区进行加锁处理
加锁的原理可以简单的理解为，某个线程要进入临界区之间，先申请对应的锁，如果获得该锁，则可以进入，并且将该锁上锁，离开临界区之后就将锁解开；如果没能申请到锁，说明当前时刻临界资源被其他线程占用，则自己进行阻塞，等待锁可以使用
同步方法之使用synchronized
synchronized时Java提供的一个重量级锁，或者称之为监视器，也称之为对象锁，可以用于修饰方法或者代码块，默认锁定的对象是this，也就是当前对象，也可以显示指定所要锁定的对象
修饰方法
class Park{
private static int counter = 0;
public synchronized void enter(){
counter++;
// ...
}
public synchronized void leave(){
counter--;
// ...
}
// ...
}
修饰代码块
class Park{
private static int counter = 0;
public void enter(){
synchronized(this){
counter++;
}
// ...
}
public void leave(){
synchronized(this){
counter--;
}
// ...
}
// ...
}
synchronizd的使用比较简单，只需要在需要进行同步的方法或者代码块加上该关键字即可，当然，synchronized还有一些比较复杂的原理，这个我们将在后面学习到
同步方法之使用locks
synchronized是在比较旧的JDK中所提供的用于同步的工具，在JDK5之后，还提供了另外的工具用于进行同步，即JUC中的Lock
import java.util.concurrent.locks.ReentrantLock;
class Park{
private static int counter = 0;
// 申请一个锁
private static Lock lock = new ReentrantLock();
public void enter(){
lock.lock();// 加锁
try {
counter++;
}finally {
lock.unlock();//解锁
}
}
public void leave(){
lock.lock();// 加锁
try {
counter--;
}finally {
lock.unlock();//解锁
}
}
public int getCounter(){
return counter;
}
}
从上面的代码中可以看到，使用Lock的操作比较繁琐，我们需要自己申请锁，并且在需要加锁的时候手动加锁，然后在离开的时候进行解锁，可能你会注意到使用时的try...finally代码块，强烈建立在使用Lock的时候采用这种方式，因为在进行资源操作的时候，可能会发生异常，采用这种方式可以保证无论在什么时候都能将锁进行解锁，还记得finally的作用吗？^_^
Lock的使用虽然比较繁琐，而且还需要自己手动加锁、解锁，但是Lock也有synchronized所不具备的特点，那就是灵活，关于这两者的具体区别，我们将在后面的内容中学习到
总结
本小节我们主要学习了线程同步的概念，临界资源、临界区的概念，没有加锁的可能带来的危害，以及常见的同步方式，synchronized的使用以及Lock使用