嗨喽～小伙伴们我来了，
上一章，我们通过几个例子（点击跳转）介绍了线程安全问题，而说到线程安全就不得不提到线程同步，它是解决线程安全的一种重要方法。本章就来简单地介绍一下线程同步。
从上一章的学习我们知道，当多个线程操作一个资源的时候，有可能由于线程的不确定切换出现数据不一致的安全问题，因此，我们要解决这个问题，就得想办法使得资源在某个时间戳只能被一个线程访问。基于这样的思想，我们提出了“队列与锁”的策略：
通俗理解，就是将所有线程排成一个队列，给要共享的资源上把锁，只有线程获得该资源的锁之后，才能访问该资源。
这也是线程同步的基本思想。所谓线程同步，是指同一进程中的多个线程相互协调工作从而达到一致性。使用线程同步，在解决线程安全问题的同时还能提高程序的性能。
基于“队列与锁”的思想，JDK中封装了一些用于实现线程同步的类和关键字。我们主要介绍synchronized 和 lock 两种。
一. synchronized
我们知道，在java中，每个对象都有一把唯一的锁，这也是synchronized实现线程同步的基础。总的来说，synchronized实现线程同步主要有三种形式：
| 形式 | 特点 |
| 实例同步方法 | 锁的是当前实例对象，执行同步代码前必须获得当前实例的锁 |
| 静态同步方法 | 锁的是当前类的class对象，执行同步代码前必须获得当前类对象的锁 |
| 同步代码块 | 锁的是括号里的对象，对给定对象加锁，执行同步代码块必须获得给定对象的锁 |
事实上，当两个线程同时对一个对象的某个方法进行调用时，只有一个线程能够抢到该对象的锁，因为一个对象只有一把锁。抢到该对象的锁之后，其他线程就无法访问该对象的所有synchronized方法，但仍可以访问该对象中的非synchronized方法。
下面，我们用代码来演示synchronized的三种用法。为了突出synchronized在线程安全方面的作用，我们采用对比（有synchronized和无synchronized）的方式来介绍。
第一种，修饰实例同步方法。首先，来看一个简单的程序：
/**
* @author sixibiheye
* @date 2021/8/31
* @apiNote synchronized用法举例
*/
public class Synchronized implements Runnable{
//公共资源
static int count = 0;
public void increase(){
count++;
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
increase();
}
}
public static void main(String[] args) throws InterruptedException {
new Thread(new Synchronized(),"A").start();
new Thread(new Synchronized(),"B").start();
Thread.sleep(2000);
System.out.println(count);
}
}
如果小伙伴们学习了上一章的内容，应该很容易看出这个程序是存在线程安全问题的，它的输出结果如下：
如果小伙伴们不太理解的话，可以去看我的上一篇博文。
上一篇博文中说到，对于“count++”，JVM是这样处理的：
1. 某线程从内存中读取count值到寄存器
2. 某线程在寄存器中修改count的值
3. 某线程将修改后的count值写入内存
简单解释一下，我们开启了两个线程去执行increase()方法，如果没有任何保护机制，假设，当count的值累加到1000时，A线程从主内存中读取到寄存器的count值为1000，执行完“count++”操作后，寄存器中的count值为1001，刚想写入内存，B线程正好抢到了CPU的使用权，开始执行run()方法，由于未写入内存，B线程从内存中读取到的count值为仍为1000，执行完“count++”操作后，B线程成功地将1001写入内存，接着A线程将自己寄存器中的count值1001写入内存（覆盖了B线程的1001），由此导致，虽然执行了两个线程，但count的值只累加了一次，这样的情况多发生几次，计算结果自然就低于20000了。
为了避免以上情况发生，我们给increase()方法加上修饰符synchronized，使得两个线程无法同时调用increase()方法，以保证上面的三步中的任何一步都不会被另外一个线程打断。
这样，“count++”操作就永远不会因线程切换而出错。代码如下：
/**
* @author sixibiheye
* @date 2021/8/31
* @apiNote synchronized用法举例
*/
public class Synchronized implements Runnable{
//公共资源
static int count = 0;
//synchronized实现线程同步
public synchronized void increase(){
count++;
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
increase();
}
}
public static void main(String[] args) throws InterruptedException {
new Thread(new Synchronized(),"A").start();
new Thread(new Synchronized(),"B").start();
Thread.sleep(2000);
System.out.println(count);
}
}
现在来看运行结果：
没有任何问题。
此外，使用synchronized时，有几个需要注意的地方，请看下面的代码：
/**
* @author sixibiheye
* @date 2021/8/31
* @apiNote synchronized用法举例
*/
public class Synchronized implements Runnable{
public synchronized void running() throws InterruptedException {
System.out.println("1");
Thread.sleep(1000);
System.out.println("2");
}
@Override
public void run() {
try {
running();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
//用同一个类创建两个对象
Synchronized sync1 = new Synchronized();
new Thread(sync1).start();
Synchronized sync2 = new Synchronized();
new Thread(sync2).start();
}
}
如果我们使用不同的对象访问，那么结果有可能是不同步的：
因为synchronized修饰实例方法时锁的对象是this对象，而使用两个对象去访问，不是同一把锁。如果我们用同一对象访问：
//只创建一个对象
Synchronized sync = new Synchronized();
new Thread(sync).start();
new Thread(sync).start();那结果是同步的：
接着，我们来看synchronized修饰静态方法的例子：
/**
* @author sixibiheye
* @date 2021/8/31
* @apiNote synchronized用法举例
*/
public class Synchronized implements Runnable{
public static synchronized void running() throws InterruptedException {
System.out.println("1");
Thread.sleep(1000);
System.out.println("2");
}
@Override
public void run() {
try {
running();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
//用同一个类创建两个对象
Synchronized sync1 = new Synchronized();
new Thread(sync1).start();
Thread.sleep(2000);
Synchronized sync2 = new Synchronized();
new Thread(sync2).start();
}
}
虽然有sync1，sync2两个对象，但是它们是同一个类对象(Synchronized.class)产生的，而synchronized修饰静态方法时，锁的是 Synchronized.class，因此两个线程仍然是同步的：
最后一种，synchronzied修饰同步代码块，它可以锁任何指定的对象，语法示例如下：
synchronized (this){
System.out.println("1");
Thread.sleep(1000);
System.out.println("2");
}this指代当前实例对象，可以换为任何对象。
那么为什么要使用同步代码块呢？
在某些情况下，我们编写的方法体可能比较庞大，同时又有一些耗时的操作，如果对整个方法体进行同步，效率会大大降低，所以我们希望能够只同步必要的代码块，对于一些不需要同步的或者耗时较长的操作，放到同步代码块之外，比如：
/**
* @author sixibiheye
* @date 2021/8/31
* @apiNote synchronized用法举例
*/
public class Synchronized implements Runnable{
public void running() throws InterruptedException {
for (int i = 0; i < 5; i++) {
System.out.println("这是耗时操作。");
}
//需要同步的代码块写下面
synchronized (this){
System.out.println("1");
Thread.sleep(1000);
System.out.println("2");
}
}
@Override
public void run() {
try {
running();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
Synchronized sync = new Synchronized();
new Thread(sync).start();
new Thread(sync).start();
}
}
运行结果如下：
再运行一次：
结果表明，需要同步的代码块确实实现了同步。
二. lock
前面使用的synchronized关键字可以实现多线程间的同步互斥，其实，在JDK1.5后新增的ReentrantLock 类同样可以实现这个功能，而且在使用上比 synchronized 更为灵活。
翻阅源码，可以看到 ReentrantLock 类实现了Lock接口：
下面我们用ReentrantLock类来实现简单的线程同步：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author sixibiheye
* @date 2021/8/31
* @apiNote ReentrantLock实现线程同步
*/
public class LockDemo implements Runnable{
private Lock lock = new ReentrantLock();
/**
*
* 按照规范，
* lock()后面应紧跟try代码块，
* 并将unlock()放到finally块的第一行
*
*/
@Override
public void run() {
//上锁
lock.lock();
try {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "线程中的i=" + i);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放锁
lock.unlock();
}
}
public static void main(String[] args)
new Thread(new LockDemo(),"A").start();
new Thread(new LockDemo(),"B").start();
}
}
其实关于Lock 和 ReentrantLock，还有许多其他的用法，限于篇幅，就不一一介绍了，有兴趣的小伙伴们可以查阅相关资料。
了解了synchronized和ReentrantLock，对于上一章提出的三个线程安全问题，便可以轻松地解决了。下面提供使用synchronized的解决方式：
/**
* @author sixibiheye
* @date 2021/8/28
* @apiNote 线程安全问题一-------取钱问题
*/
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100,"买房基金");
//你和你的妻子都要取钱
Drawing you = new Drawing(account,50,"你");
Drawing girlFriend = new Drawing(account,100,"妻子");
you.start();
girlFriend.start();
}
}
//账户
class Account{
int money; //余额
String name; //卡名
public Account(int money,String name){
this.money = money;
this.name = name;
}
}
//银行
class Drawing extends Thread{
Account account; //账户
int drawingMoney; //取的钱
int nowMoney; //现手上有的钱
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public void run() {
//注意锁的是account对象，而不是this
synchronized (account){
if(account.money - drawingMoney < 0){
System.out.println(Thread.currentThread().getName() + "钱不够了，取不了！");
return;
}
try {
sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额
account.money = account.money - drawingMoney;
//手里的钱
nowMoney = nowMoney + drawingMoney;
//打印
System.out.println(account.name + "余额为：" + account.money);
System.out.println(Thread.currentThread().getName() + "手里的钱：" + nowMoney);
}
}
}
/**
* @author sixibiheye
* @date 2021/8/27
* @apiNote 线程安全问题一-------买票问题
*/
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"小红").start();
new Thread(buyTicket,"小白").start();
new Thread(buyTicket,"小黑").start();
}
}
class BuyTicket implements Runnable{
//票数
private int tickets = 10;
//线程停止的标志位
private boolean flag = true;
//直接同步实例方法即可
private synchronized void buy() throws InterruptedException {
//判断是否有票
if(tickets <= 0){
flag = false;
return;
}
//模拟延时，保证多人都能买到票
Thread.sleep(20);
//买票
System.out.println(Thread.currentThread().getName() + "拿到了第" + tickets-- +"张票");
}
@Override
public void run() {
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
import java.util.ArrayList;
import java.util.List;
/**
* @author sixibiheye
* @date 2021/8/28
* @apiNote 线程安全问题一-------列表问题
*/
public class UnsafeList {
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread( () -> {
//同步需要修改的list对象
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
//sleep保证上述for循环跑完再输出
Thread.sleep(3000);
//输出列表大小
System.out.println(list.size());
}
}
小伙伴们可以思考一下如果使用ReentrantLock应该如何解决。
下一章，我们将着重介绍Thread类中的一些常用方法（点击跳转），好啦～本章的内容到这就结束了，喜欢的小伙伴们点个赞鼓励支持一下吧～