34 多线程（六）——线程安全 synchronized
一个小总结
Synchronized与同步块的形象比喻：
我们以去商店买衣服为比喻：synchrnized锁方法就好比去一家商店买衣服，一次只能进一个人，买完出来才能进第二个人。而同步块则是在整个买衣服流程的关键之处：试衣间换衣服，结账（假设只有一个试衣间，只有一个收银台）时做了排队处理，排队使得数据不会错乱同步块锁的就是临界资源（试衣间、收银台）。
概念
关键字synchronized可以写在方法和代码块中
- 写在普通方法中：锁住的对象是this，即类的实例。也就是说锁住的是类下面的类变量（成员变量），而不是方法中的变量。
- 写在静态方法中：锁住的对象时class
- 写在代码块中，只锁住代码块中的内容
关于这个synchronized关键字
- 线程锁会造成性能下降
- 线程锁用在大的方法中，很影响性能
关于线程锁
- 除了使用synchronized关键字外，还可以使用另一种线程锁，本文没有收录方法
写在方法声明中：synchronized锁对象
案例1
下面来看一个没有加线程锁的案例：3个线程抢票
package _20191205;
/**
* 线程不安全：
* @author TEDU
*/
public class SynTest01 {
public static void main(String[] args) {
//一份资源
SafeWeb12306 web = new SafeWeb12306();
new Thread(web,"线程1").start();
new Thread(web,"线程2").start();
new Thread(web,"线程3").start();
}
}
class SafeWeb12306 implements Runnable{
//票数
private int ticketNums = 100;
private boolean flag = true;
@Override
public void run() {
while(flag) {
try{
Thread.sleep(100);
}catch(InterruptedException e) {
e.printStackTrace();
}
buy();
}
}
//买票：线程不安全
public void buy() {
if(ticketNums<=0) {
flag = false;
return;
}
try {
Thread.sleep(100);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);
}
}
它的运行结果：
会出现多个线程抢了同一张票的情况，为了避免这种情况，我们需要给关键方法加锁，在本例中，我们只需要给buy()方法加锁即可，即：
public void synchronized buy(){...}
注意的地方
注意我们只new了一个资源的实例，当三个线程对它的成员变量进行操作时，才能使用synchronized对这个实例进行线程保护，锁住这个实例的成员变量。
SafeWeb12306 web = new SafeWeb12306(); new Thread(web,"线程1").start(); new Thread(web,"线程2").start(); new Thread(web,"线程3").start();
案例2 这个例子就不要看了
两个人都持有同一个账户的银行卡。
现两人同时使用两台ATM机取款，要保证线程安全，就要在增加和减少账户余额的方法中加入sychronized关键字
package _20191205;
import java.util.Scanner;
/**
* synchronized案例
* @author TEDU
*模拟两个人从取款机取同一个账户
*人类，取款机类，银行账户类，账户数据库类
*线程锁锁的是账户数据库类，也就是锁在这个类的取款与存款方法
*/
public class synTest02 {//测试类
public static void main(String[] args) {
DataBase db = new DataBase();//生成一个账户的数据库（相当于一张卡）
Man m1 = new Man("小明",db);//两个人都持有这张卡
Man m2 = new Man("小李",db);//两个人都持有这张卡
new Thread(m1,"人1").start();;
new Thread(m1,"人2").start();
}
}
class Man implements Runnable{
private String name;
private ATM atm;
private DataBase db;
public Man(String name,DataBase db) {
this.name = name;
this.db = db;
}
//与ATM交互
public void operateATM() {
System.out.println(name+"正在操作ATM机，掏出准备好的小纸条：账号111，密码222");
atm = new ATM(db);
atm.logIn();
System.out.println(name+"已经操作完ATM机");
}
@Override
public void run() {
// TODO Auto-generated method stub
operateATM();
}
}
class ATM {
private DataBase db;
public ATM(DataBase db) {
this.db = db;
}
Account account;
//查询余额方法
private void inquire() {
account.doMath("inquire");
}
//取款方法
private void withDraw() {//传入要取的数量
int num;
Scanner scan = new Scanner(System.in);
System.out.println("请输入取款金额：");
num = scan.nextInt();
account.doMath("sub",num);
}
//存款方法
private void save() {
int num;
Scanner scan = new Scanner(System.in);
System.out.println("请假装整理好您的钞票，假装放进取款机！");
num = scan.nextInt();
System.out.println("存入中，请稍后......");
account.doMath("add",num);
System.out.println("存入成功！");
}
public void logIn() {//登入方法
int command;//用于接收用户命令
System.out.println("======欢迎使用口袋银行ATM系统======");
Scanner scan = new Scanner(System.in);
System.out.println("请输入账号：");
String acc = scan.nextLine();
System.out.println("请输入密码：");
String psd = scan.nextLine();
account = new Account(acc,psd,db);
//判断账户与密码是否存在
if(account.compare()) {
//账户密码均正确
System.out.println("登入成功！");
do {
System.out.println("请选择您的操作：1.查询余额 2.取款 3.存款 0.退出");
command = scan.nextInt();
switch(command) {
case 0:
break;
case 1:
//查询余额方法
inquire();
break;
case 2:
//调用取款方法
withDraw();
break;
case 3:
//调用存款方法
save();
break;
default:
System.out.println("输入错误！");
break;
}
}while(command!=0);
}else {
System.out.println("账户或密码错误");
}
}
}
class Account{
private DataBase db;
private String accountName;
private String passwd;
public Account(String accountName,String psd,DataBase db) {
this.accountName = accountName;
this.passwd = psd;
this.db = db;
}
//判断用户输入的账号密码是否正确
public boolean compare() {
if(db.getAccountName().contentEquals(accountName)&&db.getPasswd().contentEquals(passwd)){
return true;
}else {
return false;
}
}
//账户余额做计算
public void doMath(String act,int num) {
if(act.equals("add")) {
//账户添加余额
db.addBalance(num);
}
if(act.equals("sub")) {
//账户减少余额
db.subBalance(num);
}
}
public void doMath(String act) {
if(act.equals("inquire")) {
System.out.println("您的账户余额为:￥"+db.getBalance());
}
}
}
//本数据库只存了一个账户的信息
class DataBase{
private String accountName = "111";
private String passwd = "222";
private int balance = 10000;//账户余额1w
//增加余额方法
public synchronized void addBalance(int num) {
this.balance += num;
}
//减少余额
public synchronized void subBalance(int num) {
if(num>balance) {
System.out.println("余额不足");
}else {
this.balance -= num;
System.out.println("出钞中，请稍后......");
System.out.println("请尽快取走钞票！");
}
}
public int getBalance() {
return balance;
}
public String getAccountName() {
return accountName;
}
public String getPasswd() {
return passwd;
}
}
运行结果
小明正在操作ATM机，掏出准备好的小纸条：账号111，密码222 小明正在操作ATM机，掏出准备好的小纸条：账号111，密码222 ======欢迎使用口袋银行ATM系统====== ======欢迎使用口袋银行ATM系统====== 请输入账号： 请输入账号： 111 111 请输入密码： 请输入密码： 222 222 登入成功！ 请选择您的操作：1.查询余额 2.取款 3.存款 0.退出 登入成功！ 请选择您的操作：1.查询余额 2.取款 3.存款 0.退出 1 1 您的账户余额为:￥10000 请选择您的操作：1.查询余额 2.取款 3.存款 0.退出 您的账户余额为:￥10000 请选择您的操作：1.查询余额 2.取款 3.存款 0.退出 2 2 请输入取款金额： 请输入取款金额： 8000 8000 出钞中，请稍后...... 请尽快取走钞票！ 请选择您的操作：1.查询余额 2.取款 3.存款 0.退出 余额不足 请选择您的操作：1.查询余额 2.取款 3.存款 0.退出 1 1 您的账户余额为:￥2000 请选择您的操作：1.查询余额 2.取款 3.存款 0.退出 您的账户余额为:￥2000 请选择您的操作：1.查询余额 2.取款 3.存款 0.退出
写在代码块中：synchronized锁（同步块）案例
synchronized块的优点为：更细致的对需要线程同步的部分进行加锁，优化代码，使性能提高。
格式：
synchronized (obj) {...} //obj为监视器，即要锁住的对象，注意是对象，不是属性
注意：
- 无论是基础数据类型还是引用数据类型，如果它的改变会引起线程不安全，那它们都要加线程锁
- 要锁住的是对象，注意是对象（引用类型），不是属性（基础类型）
- 被锁的对象可以是this（如果有多个被修改的对象时）
- synchronized关键字要与被锁的对象被修改的地方尽可能近
- synchronized块只能锁一个对象，如果需要需要
案例1
1w个并发线程向一个ArrayList中添加自己的线程名，最后看看这个容器的大小是不是1w。
注意：
- 重点在这里，synchronized代码要与被锁的对象尽可能近
- 被锁的对象可以是this
package _20191205;
import java.util.List;
import java.util.ArrayList;
public class SynBlockTest02 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for(int i = 0;i < 10000;i++ ) {
new Thread(()->{
synchronized (list) {//重点在这里，synchronized代码要与被锁的对象使用的地方尽可能近
list.add(Thread.currentThread().getName().toString());
}
},"线程"+i).start();
}
try {
Thread.sleep(8000);//这里休眠8s是因为我们for循环里的线程与main线程是并发的，如果不写休眠，可能main就很快把容器的容量输出来了，就得不到正确的结果
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
// for(String str : list) {
// System.out.println(str);
// }
}
}
案例2 三个线程抢100张票
本例的重点在于，需要保证线程安全的对象时基础数据类型，而且不止一个基础数据类型被修改，则在这个线程安全中obj为this，代表这两个基础数据类型所在的类的对象。
package _20191205;
/**
* 线程安全：在并发时保证数据的正确性、效率尽可能的高
* synchronized锁方法案例
* @author TEDU
*
*/
public class SynTest01 {
public static void main(String[] args) {
//一份资源,注意我们只new了一个资源的实例，当三个线程对它进行操作时，才能使用synchronized对他锁住资源线程保护
SafeWeb12306 web = new SafeWeb12306();
new Thread(web,"线程1").start();
new Thread(web,"线程2").start();
new Thread(web,"线程3").start();
}
}
class SafeWeb12306 implements Runnable{
//票数
private int ticketNums = 100;
private boolean flag = true;
@Override
public void run() {
while(flag) {
try{
Thread.sleep(100);
}catch(InterruptedException e) {
e.printStackTrace();
}
buy2();
}
}
//买票：线程安全的买 通过synchronized块
public void buy2() {
//这里再写一遍是因为代码优化，没有票就没有必要等了，考虑的是没有票的情况
if(ticketNums<=0) {
flag = false;
return;
}
//必须涵盖所有会被修改的地方，这里会被修改的地方即flag与ticketNums
synchronized(this) {//由于ticketNums是属性是基础数据类型，不是引用类型，所以直接用this，表示ticketNums所在的类
if(ticketNums<=0) { //这里写，是考虑只有一张票的情况（三个线程都读到了这张票）
flag = false;//被修改的地方1
return;
}
try {
Thread.sleep(100);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);//被修改的地方2
}
}
}
