多线程在考虑线程安全时，一定要考虑临界区，即被多个线程所共享的变量，在多线程种是否发生了读写操作，如果发生了，就可能会出现线程安全问题，需要保证线程安全。
卖票问题
卖票问题代码如下：
package com.bo.threadstudy.two;
import lombok.extern.slf4j.Slf4j;
import java.util.*;
/**
* 卖票方法的测试类，首先需要一个票站，多个窗口卖票通过这个票站对象执行
*/
@Slf4j
public class SellTicketTest {
public static void main(String[] args) throws InterruptedException {
SellTicketWindow sellTicketWindow = new SellTicketWindow(2000);
//抢票人数，每个线程都有5000人抢票
int personNum = 5000;
List<Integer> ticketSum = new Vector<>();
Random random = new Random();
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < personNum; i++) {
Thread t = new Thread(() -> {
int i1 = sellTicketWindow.subtractNum();
try {
Thread.sleep(random.nextInt(5)+1);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketSum.add(i1);
});
threads.add(t);
t.start();
}
for (Thread thread : threads) {
thread.join();
}
log.debug("出售票数为"+ticketSum.stream().mapToInt(c ->c ).sum());
log.debug("售完票数为"+sellTicketWindow.getNum());
}
}
/**
* 票站类
*/
@Slf4j
class SellTicketWindow{
//票数
private Integer num;
SellTicketWindow(Integer num){
this.num = num;
}
//得到当前票数
public Integer getNum(){
return num;
}
//售卖票数
public synchronized int subtractNum() {
if(num <= 0){
return 0;
}
num--;
log.debug("卖票数"+getNum());
return 1;
}
}
因为临界区肯定是对线程共享数据操作的位置，即num--的位置，所以我在方法上直接加了synchronized，也可以在num代码上直接添加代码块即可。
代码不难写，但是，先考虑一下锁的粒度，synchronized加成同步方法这个粒度是否有点过大。
那么这个粒度该怎么控制
//售卖票数
public int subtractNum() throws InterruptedException {
//如果在这里加synchronized的情况下，虽然会及时写到主存中，但是num这里会出现指令乱序问题
//第一个线程我从主存得到num=1.第二个线程我从主存也得到num=1，可以理解为
// if(num>0){
// synchronized (this){
// num--;
// }
// }
//这种还是会出现线程问题的
if (num <= 0) {
return 0;
}
synchronized (this) {
Thread.sleep(100);
num--;
}
log.debug("卖票数" + getNum());
return 1;
}为什么临界区一直要强调读写操作，而不是单独的写操作。如果我这里只加到n--上时，此时只在写操作上加锁，加个睡眠时间，票数置为1，而抢票人置为2。代码如下：
package com.bo.threadstudy.two;
import lombok.extern.slf4j.Slf4j;
import java.util.*;
/**
* 卖票方法的测试类，首先需要一个票站，多个窗口卖票通过这个票站对象执行
*/
@Slf4j
public class SellTicketTest {
public static void main(String[] args) throws InterruptedException {
SellTicketWindow sellTicketWindow = new SellTicketWindow(1);
//抢票人数，每个线程都有5000人抢票
int personNum = 2;
List<Integer> ticketSum = new Vector<>();
Random random = new Random();
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < personNum; i++) {
Thread t = new Thread(() -> {
int i1 = 0;
try {
i1 = sellTicketWindow.subtractNum();
Thread.sleep(random.nextInt(5) + 1);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketSum.add(i1);
});
threads.add(t);
t.start();
}
for (Thread thread : threads) {
thread.join();
}
log.debug("出售票数为" + ticketSum.stream().mapToInt(c -> c).sum());
log.debug("售完票数为" + sellTicketWindow.getNum());
}
}
/**
* 票站类
*/
@Slf4j
class SellTicketWindow {
//票数
private Integer num;
SellTicketWindow(Integer num) {
this.num = num;
}
//得到当前票数
public Integer getNum() {
return num;
}
//售卖票数
public int subtractNum() throws InterruptedException {
//如果在这里加synchronized的情况下，虽然会及时写到主存中，但是num这里会出现指令乱序问题
//第一个线程我从主存得到num=1.第二个线程我从主存也得到num=1，可以理解为
// if(num>0){
// synchronized (this){
// num--;
// }
// }
//这种还是会出现线程问题的
if (num <= 0) {
return 0;
}
synchronized (this) {
Thread.sleep(100);
num--;
}
log.debug("卖票数" + getNum());
return 1;
}
}结果如下：
发现出现问题了，原因在哪里？
试想一下，num目前为1的情况下，线程1在
if (num <= 0) {
return 0;
}
这句话时，此时线程因为来不及执行num--方法，num依旧等于1。
此时CPU将时间片划分给线程2，此时线程2也执行这个if语句，因为num=1，所以这个条件不满足，接着往下执行。
接下来存在两种可能了。
线程1接收到时间片，执行num--操作，然后在将结果写入至主存之前是否再次切换线程，在线程2中执行num--。下面是这两种场景。
第一种，线程1将结果写入主存后，由线程1切换至线程2，主存此时num=0，然后在线程2中执行num--操作，再写到主存中，此时num最终结果就为-1。
第二种，线程1中num--操作已经执行完成了但未写到主存，工作区间内num=0，但主存中num=1，而此时线程1切换至线程2，在线程2中会对num再次执行一次num--，虽然得到的结果num=0没有问题。但售票这个操作，一张票还是卖了两次，存在问题。
所以，如果要保证原子性，这个if也必须加到synchronized中。在多线程访问中，涉及到多线程写操作的情况下，也必须得考虑多线程的读操作是否会导致线程安全问题。
public int subtractNum() throws InterruptedException {
//如果在这里加synchronized的情况下，虽然会及时写到主存中，但是num这里会出现指令乱序问题
//第一个线程我从主存得到num=1.第二个线程我从主存也得到num=1，可以理解为
// if(num>0){
// synchronized (this){
// num--;
// }
// }
//这种还是会出现线程问题的
synchronized (this) {
if (num <= 0) {
return 0;
}
Thread.sleep(100);
num--;
}
log.debug("卖票数" + getNum());
return 1;
}不理解操作系统底层，这种东西真的很难捋，后期有时间一定得看看操作系统。
总结一下，多线程涉及到共享变量条件判定，以及写操作等情况下，一定要考虑从线程安全问题。
转账问题
非线程安全的代码如下
package com.bo.threadstudy.two;
import lombok.extern.slf4j.Slf4j;
/**
* 转账问题（转账肯定涉及到账户,所以需要有一个账户类）
*/
@Slf4j
public class TransferTest {
//一个账户肯定不能并发去给其它用户转账，但是其它用户可以给这个账户转账，从而也会出现并发问题
public static void main(String[] args) throws InterruptedException {
int loopNum = 1000;
Account account1 = new Account(2000);
Account account2 = new Account(3000);
//1账户给2账户转账
Thread t1 = new Thread(() -> {
for (int i = 0; i < loopNum; i++) {
account1.accountMoney(1,account2);
}
},"t1");
//2账户给1账户转账
Thread t2 = new Thread(() -> {
for (int i = 0; i < loopNum; i++) {
account2.accountMoney(1,account1);
}
},"t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("t1账户为"+account1.getMoney());
log.debug("t2账户为"+account2.getMoney());
}
}
class Account{
//图省事，暂时先不管精度
private int money = 0;
public Account(int money){
this.money = money;
}
public int getMoney(){
return money;
}
public void setMoney(int money){
this.money = money;
}
/**
* 转账操作
* @param money 转账金额
* @param account 转账账户
*/
public void accountMoney(int money,Account account){
if(this.money < money){
//转账失败
return ;
}
//自身账户减少转账记录
this.money = this.money - money;
//转账账户增加金额
account.setMoney(account.getMoney()+money);
//在不加锁的情况下，该怎么让线程嵌套出现问题呢
//首先，account1以及account2两个对象中的金额都是共享变量，在转账过程中都对money进行了操作
//假设线程1走到 this.money = this.money - money;，线程2走到account.setMoney(account.getMoney()+money);
//此时，线程1计算完this.money计算完成却没有写到主存中，而后线程2计算完成，写到主存中，但是线程1又将自己计算的结果写到主存中，出现异常
}
}这里的锁对象就不能使用this了，因为synchronized会根据获取到的锁对象保证执行程序的先后顺序。而这里的转账对象，一个是account1转账对象，另一个是account2转账对象。而这里如果用this，锁资源都不是一个，无法保证程序执行的指令有序。所以如果想保证有序，可以采用共享的对象，比如Account.class。
性能虽然会差点，但是不会存在线程安全问题。
总结：在使用多线程调用某个方法时，需要考虑当前方法上锁的锁对象。就像这个场景，入参调用了当前类的其它对象，会存在对象1调用对象2，对象2调用对象1的场景，多线程就会出事。一定要保证各种业务场景下调用锁时，符合业务操作，合理使用锁。
827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
