『Java练习生的自我修养』java-se进阶² • 并发与多线程

☕☕ Java进阶攻坚克难，持续更新，一网打尽IO、注解、多线程…等java-se进阶内容。

---

前言：

多线程虽然提高了程序的执行效率，但随之而来的是线程安全问题：当多个线程访问或操作同一个资源时，就会产生意想不到的错误。

比如执行下面的代码块：

public class Demo {

    public static int x = 0;

    public static void main(String[] args) {
        new Thread(() -> x++).start();
        new Thread(() -> x++).start();
        System.out.println("x = " + x);
    }
}

同时开启两个线程，每个线程都对同一个x进行自增操作，直观感觉输出结果是x = 2，然而实际的输出结果却是x = 1。这是由于自增这条代码不是原子性操作，简单理解就是两个线程同时读取了x = 0，在每个线程内部进行了一次自增操作，两个线程执行完x的值都是1，再将1写回内存，结果就相当于x只自增了一次，同我们的预期相反，这就是所谓的线程不安全。

---

并发时的线程安全

再来看一个卖票的例子：售票站有100张票，开放三个窗口进行售票操作。用代码模拟就是有一个初始值为100的变量ticket，同时开启三个线程对ticket执行自减操作，直到ticket减到0为止。

public class TicketSales implements Runnable{

    public int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                try {
//                    为了让结果出现的错误更明显，设置成10ms卖一张票
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (101 - ticket--) + "张票");
            }
        }
    }

    public static void main(String[] args) {
        TicketSales ts = new TicketSales();
        new Thread(ts).start();
        new Thread(ts).start();
        new Thread(ts).start();
    }
}

以上代码不对线程进行任何限制，买票的结果如下：

可以看到三个线程不仅会卖同一张票，甚至在最后还卖出了第101张本来不存在的票！

为了解决线程安全问题，就必须对访问同一资源的线程做出一定限制，在Java中使用锁机制来实现这一点。

---

Java中的锁机制

⛅⛅⛅
锁机制是线程同步技术的一种。既然线程的并发执行可能会导致线程不安全，那么不妨将线程的并发执行改成按顺序执行，也就是对线程中可能访问同一资源的代码片段上锁，使其在一段时间内只允许一个线程处于运行状态，而其他线程必须等待得到锁的线程执行完毕，释放出锁以后才能继续执行，通过锁机制实现多线程的同步。
⛅⛅⛅

Java多线程并发的内容实在太过庞大，都可以单独写一本书了，作为刚刚接触多线程的新手来说掌握以下三种上锁方法就够用了：

1. synchronized()对象锁
2. synchronized同步方法
3. Lock锁

1.使用锁对象

锁对象又叫对象锁、同步锁或者叫对象监视器。通过synchronized（obj）{代码段}声明一个锁对象，使用obj对象作为锁，多个线程并发执行时，遇到synchronized代码块会一起争夺锁，谁抢到了谁就获得cpu执行权，执行代码块中的内容，其余线程此时进入阻塞状态；待得到锁的线程执行完代码段释放锁后，其余线程会继续争夺锁，谁抢到谁获得cpu执行权…

下面我们通过JOL对象解析工具来看一下对象被当成锁的前后有什么变化：

import org.openjdk.jol.info.ClassLayout;

public class LockTest {

    public static void main(String[] args) {
//        使用Object对象作为锁
        Object o = new Object();
//        在没声明锁时o对象的头部信息
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        synchronized (o) {
            System.out.println("声明了一个对象锁后：");
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }
}

观察对象的头部信息：

可以发现synchronized()是如何将对象当成一把锁的：改变对象头部信息的数值标记。

⭐对象锁的特点：

• 使用一个对象作为锁，锁对象可以任意，一般使用Object o就可以。
• 访问同一资源的多线程必须使用同一个锁对象。
• 作用：只让一个线程在同步代码块中执行。
• synchronized声明的是一个重量级锁，或者叫悲观锁，只有得到锁线程才能运行，其余线程都被阻塞。

通过锁对象改造卖票案例：

public class TicketSales_Solution implements Runnable{

    public int ticket = 100;

//    创建一个锁对象
    Object o = new Object();

    @Override
    public void run() {
        while (true) {
//            同步代码块
            synchronized (o) {
                if (ticket > 0) {
                    try {
    //                    为了让结果出现的错误更明显，设置成10ms卖一张票
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + (101 - ticket--) + "张票");
                }
            }
        }
    }

    public static void main(String[] args) {
        TicketSales_Solution ts = new TicketSales_Solution();
        new Thread(ts).start();
        new Thread(ts).start();
        new Thread(ts).start();
    }
}

通过锁对象synchronized同步代码块可以解决线程同步问题，卖票案例成功得到我们想要的效果。

2.使用同步方法

⭐解决线程安全问题的第二种方法—使用同步方法：

1. 把访问了共享数据的代码抽取出来，放到一个方法中。
2. 在方法上添加synchronized修饰符。

⭐定义方法的格式：

修饰符 synchronized 返回值类型 方法名 （参数列表） {
	可能会出现线程安全问题的代码（访问共享数据）
}

通过同步方法改造卖票案例：

public class TicketSales_Solution implements Runnable {

    public int ticket = 100;

//    将卖票的代码抽取出来
    public synchronized void payTickets() {
        if (ticket > 0) {
            try {
//                    为了让结果出现的错误更明显，设置成10ms卖一张票
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (101 - ticket--) + "张票");
        }
    }

    @Override
    public void run() {
        while (true) {
            payTickets();
        }
    }

    public static void main(String[] args) {
        TicketSales_Solution ts = new TicketSales_Solution();
        new Thread(ts).start();
        new Thread(ts).start();
        new Thread(ts).start();
    }
}

同样可以得到想要的结果：

【注1】 既然同步方法也使用了synchronized关键字，肯定也需要一个对象作为锁，那么问题来了，充当锁的对象是谁？

• ‍答：同步方法的锁对象是实现类对象，即当前对象，也就是我们常说的this。

• ‍答：也就是说我们抽取出来的代码还有一个等价写法—使用锁对象：

  //    将卖票的代码抽取出来
  public void payTickets() {
  //		使用锁对象，与同步方法等价的写法
  	synchronized (this) {
      	if (ticket > 0) {
          try {
  //                为了让结果出现的错误更明显，设置成10ms卖一张票
              	Thread.sleep(10);
          	} catch (InterruptedException e) {
              	e.printStackTrace();
          	}
          	System.out.println(Thread.currentThread().getName() + "卖出了第" + (101 - ticket--) + "张票");
      	}
  	}
  }
  

【注2】 同步方法还可以在前面加上关键字static使其成为静态同步方法：

//  静态方法只能访问静态变量，这里注意要用static修饰
public static int ticket = 100;

//    将卖票的代码抽取出来，并声明为静态方法
public static synchronized void payTickets() {
    if (ticket > 0) {
        try {
//            为了让结果出现的错误更明显，设置成10ms卖一张票
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "卖出了第" + (101 - ticket--) + "张票");
    }
}

这里问题又来了，this是创建对象之后产生的，静态方法优先于对象，this不能当成对象锁，那么静态同步方法中谁来充当锁？

• ‍答：静态方法的锁对象是本类的class属性。

3.使用Lock锁

Lock锁是JDK1.5之后的新增特性，相比于传统的synchronized锁，Lock锁同时提供了lock()与unlock()方法，使用起来更加灵活。

解决线程安全问题的第三种方式—Lock锁：

• Lock接口在java.util.concurrent.locks包下，其实现类为java.util.concurrent.locks.Reentrantlock。
• Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
• Lock接口中的方法：
  • void lock()：获取锁。
  • void unlock()：释放锁。

使用步骤：

1. 在成员位置创建一个ReentrantLock对象。
2. 在可能会出现线程安全问题的代码前调用Lock接口中的lock()方法获取锁。
3. 在可能会出现线程安全问题的代码后调用Lock接口中的lock()方法获取锁。

使用Lock锁改造卖票案例：

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

public class TicketSales_Solution implements Runnable {

    public int ticket = 100;

//    在成员位置创建一个ReentrantLock对象
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
//            在可能会出现线程安全问题的代码前调用Lock接口中的lock()方法获取锁
            lock.lock();
            if (ticket > 0) {
                try {
//                    为了让结果出现的错误更明显，设置成10ms卖一张票
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (101 - ticket--) + "张票");
            }
//            在可能会出现线程安全问题的代码后调用Lock接口中的lock()方法获取锁
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        TicketSales_Solution ts = new TicketSales_Solution();
        new Thread(ts).start();
        new Thread(ts).start();
        new Thread(ts).start();
    }
}

依然可以的到我们想要的结果：

下篇预告：线程的等待与唤醒

创作不易，如果觉得本文对你有所帮助，欢迎点赞、关注、收藏。‍♀️

@作者：Mymel_晗，计算机专业练习时长两年半的Java练习生~‍♂️

文末已至，咱们下篇再见

---

┊且将新火试新茶，诗酒趁年华┊ 望江南·超然台作-苏轼