【学习笔记】线程（六）之线程同步
线程同步
-
并发：同一个对象被多个线程同时操作
-
上万人同时抢100张票
-
两个银行同时取钱
-
-
在现实生活中，我们遇到“同一个对象被多个线程同时操作”这种问题，比如食堂打饭，解决办法就是排队
-
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程在使用。
-
队列和锁：在线程访问对象时，加入锁机制 synchronized, 当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题
-
一个线程持有锁会导致其他所有需要此锁的线程挂起
-
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换，和调度延时，引起性能问题
-
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级导致，引起性能问题
-
三大不安全案例
买票案例
package com.thread.syn;
public class UnsafeTicket {
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 ticketNum = 10;
boolean flag = true; //外部停止方式
@Override
public void run() {
while(flag){
buy();
}
}
public void buy(){
if (ticketNum < 0){
flag = false;
return;
}
//延时：防止一个人抢到所有票
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");
}
}
线程不安全，票数出现负数
每个线程都在自己的工作内存交互，内存控制不当会造成数据不一致
买票时，每个线程都把票数拿到自己的内存，当票数只剩一张时，所以它们看到的都是1，然后都去拿这一张票，当第一个线程拿到这张票时，票数修改为0，第二个线程再去拿时，票数就变成了-1.
银行取钱案例
package com.thread.syn;
public class UnsafeBank {
public static void main(String[] args) {
Account account = new Account(100);
Bank you = new Bank(account,50,"你");
Bank other =new Bank(account,100,"其他人");
you.start();
other.start();
}
}
//账户
class Account {
int balance; //余额
public Account(int balance){
this.balance = balance;
}
}
//银行
class Bank extends Thread{
Account account;
int wantTake; //想要取得钱
int remain; //手里的钱
String name; //谁取
public Bank(Account account,int wantTake,String name){
super(name);
this.account = account;
this.wantTake = wantTake;
}
@Override
public void run() {
if (account.balance - wantTake <0){
System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.balance = account.balance - wantTake;
remain = remain + wantTake;
System.out.println(Thread.currentThread().getName() + "取了" + wantTake);
System.out.println(Thread.currentThread().getName() + "手里有" + remain);
System.out.println("卡里余额：" + account.balance);
}
//取钱
public void withDraw(){
}
}
线程不安全的集合
以ArrayList 为例
package com.thread.syn;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList{
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
System.out.println("集合中元素的数量："+list.size());
}
}
我们加入了10000个元素，实际加入集合的只有7761个，原因是当这些线程在同一瞬间把集合元素添加到集合的同一位置，就覆盖掉了前面的元素，所以集合中的元素数量才会少
如何解决不安全的问题？
同步方法
-
我们要针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：
synchronized 方法 和 synchronized 块
同步方法：public synchronized void method(int args){}
-
synchronized 方法控制对“对象”的访问，每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程获得这个锁，继续执行
-
缺陷：若将一个大的方法申明为 synchronized 将会影响效率
方法中需要修改的内容才需要锁，锁的太多，浪费资源
修改买票案例
在买票的方法前加上 synchronized
public synchronized void buy(){
if (ticketNum < 0){
flag = false;
return;
}
//延时：防止一个人抢到所有票
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");
}
修改银行取钱案例
按照上面的思路，我们应该去锁取钱的方法，即 run()方法
@Override
public synchronized void run() {
if (account.balance - wantTake <0){
System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.balance = account.balance - wantTake;
remain = remain + wantTake;
System.out.println(Thread.currentThread().getName() + "取了" + wantTake);
System.out.println(Thread.currentThread().getName() + "手里有" + remain);
System.out.println("卡里余额：" + account.balance);
}
但是结果依然是不安全的，原因就是我们锁run()方法，它默认锁的是this 即银行Bank，但是我们操作的对象是账户 Account，所以我们应该锁 账户 Account
但是我们没有办法用同步方法直接锁Account ，所以我们可以用同步块去锁
@Override
public void run() {
synchronized(account){
if (account.balance - wantTake <0){
System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.balance = account.balance - wantTake;
remain = remain + wantTake;
System.out.println(Thread.currentThread().getName() + "取了" + wantTake);
System.out.println(Thread.currentThread().getName() + "手里有" + remain);
System.out.println("卡里余额：" + account.balance);
}
}
-
锁的对象就是需要变化的量，需要增删改
修改线程不安全的集合
我们可以锁 list 集合
package com.thread.syn;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList{
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
Thread.sleep(3000);
System.out.println("集合中元素的数量："+list.size());
}
}
JUC 安全类型的集合
JUC: java.util.concurrent ：并发包
在JUC下有一个线程安全的集合 ：CopyOnWriteArrayList
package com.thread.syn;
import java.util.concurrent.CopyOnWriteArrayList;
public class TestJUC {
public static void main(String[] args) throws InterruptedException {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(3000);
System.out.println("集合中元素的数量：" + list.size());
}
}
