多线程
6 线程同步
同步方法
- 由于我们可以通过
private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括以下两种用法：
synchronized方法和synchronized块
- 同步方法：
public synchronized void nethod(int args) {}
synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞。方法一旦执行，就会独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大的方法声明为synchronized，将会影响效率。在方法中，需要修改的内容才需要锁（只读的内容不必同步修改），锁的太多自然会浪费资源。
- 同步块：
synchronized(Obj) {}
- Obj称为同步监视器
- Obj可以是任何对象，但推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，即这个对象本身，或者是class(反射中会涉及)
- 同步监视器的执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码
- 第二个线程访问，发现同步监视器被锁定，无法访问
- 第一个线程访问完毕，解锁同步监视器
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
在上节所提到的三个不安全案例中，通过同步方法进行修改完善，可以发现代码运行结果发生了显著变化，并且是我们所期望看到的。
- 买票案例改：
package com.duo.synchronize;
//不安全案例1：买票
public class UnsafeCase1 {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station, "Hua").start();
new Thread(station, "Ming").start();
new Thread(station, "Hong").start();
}
}
class BuyTicket implements Runnable {
private int ticketNum = 10;
boolean flag = true;
@Override
public void run() {
while (flag) {
buy();
}
}
//添加修饰词synchronized之后，此方法变为同步方法,锁的是this
private synchronized void buy() {
if (ticketNum <= 0) {
flag = false;
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");
}
}
运行结果：
在运行中，输出结果是间隔一秒挨个输出，且不再存在抢到同一张票的情况(即多个线程同时操作一个同一个对象)，也没有负数出现。
- 银行取钱案例改：
package com.duo.synchronize;
//不安全案例2：银行两人同时取钱
public class UnsafeCase2 {
public static void main(String[] args) {
Account account = new Account(1_000_000, "基金");
Withdraw husband = new Withdraw(account, 500_000, "丈夫");
Withdraw wife = new Withdraw(account, 1_000_000, "妻子");
husband.start();
wife.start();
}
}
class Account {
int balance;
String name;
public Account(int balance, String name) {
this.balance = balance;
this.name = name;
}
}
class Withdraw extends Thread {
Account account; //账户
int transaction; //交易金额
int change; //现在手中的零钱总金额
public Withdraw(Account account, int transaction, String name) {
super(name);
this.account = account;
this.transaction = transaction;
}
//取钱
@Override
public void run() { //若在此处添加synchronized修饰词并不会达到期望的效果，默认锁的是this
synchronized (account) {
if (account.balance - transaction < 0) {
System.out.println(Thread.currentThread().getName() + "：账户余额不足，交易失败");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.balance -= transaction;
change += transaction;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//Thread.currentThread().getName() == this.getName()
System.out.println(this.getName() + "手中当前金额：" + change);
System.out.println(account.name + "账户当前余额为：" + account.balance);
}
}
}
运行结果：
可以看到，通过synchronized可以控制对对象的访问。需要注意的是，此案例中不能直接在取钱的run()方法处添加synchronized修饰词，因为synchronized默认锁的是this，无法实现对账户account的锁定，故需将整个方法放入synchronized块中。
- 线程的不安全集合改：
package com.duo.synchronize;
import java.util.ArrayList;
import java.util.List;
//不安全案例3：线程不安全的集合
public class UnsafeCase3 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 5000; i++) {
new Thread(() -> {
synchronized (list) {
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
运行结果：
可以看到，在将list.add(Thread.currentThread().getName());放入synchronized块中后，集合列表输出的元素个数大小等于设定值5000.
【补充】JUC安全类型的集合测试
package com.duo.synchronize;
import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC安全类型的集合
public class JUCTest {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(); //集合都加上泛型，规范
for (int i = 0; i < 5000; i++) {
new Thread(() -> {
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
运行结果：
可以发现，在使用JUC安全类型的集合时，即使没有使用synchronized方法或synchronized块包裹，最终输出结果也是安全的。
