JAVA多线程--Thread(5)

最新推荐文章于 2022-03-16 10:18:35 发布

zxy7857

最新推荐文章于 2022-03-16 10:18:35 发布

阅读量138

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/zxyccm/article/details/122746409

版权

线程同步

多个线程操作一个资源

并发：同一个对象被多个线程同时操作
处理并发问题：线程同步，实质是等待机制，形成队列
形成条件：队列+锁 保证安全性
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized,当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，会引起性能问题
- 如果是一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题

三大不安全案例

不安全买票

package Thread;

/* 线程不安全，有复数，也有两个人取到同一张票 */
public class UnsafeBuyTicket {

	public static void main(String[] args) {
		
		BuyTicket station = new BuyTicket();
		
		new Thread(station,"小王").start();
		new Thread(station,"小李").start();
		new Thread(station,"小张").start();
		
	}
	
}

class BuyTicket implements Runnable{

	private int ticketNum = 10;
	
	/* 外部停止方式 */
	boolean flag = true;
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		while(flag) {
			buy();
		}
		
	}
	
	public void buy() {
		
		/* 判断是否有票 */
		if(ticketNum <= 0) {
			
			flag = false;
			return;
			
		}
		
		/* 模拟延时 */
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		/* 买票 */
		System.out.println(Thread.currentThread().getName()+
				"拿到"+ticketNum--);
	}
	
}

不安全取钱

package Thread;

/* 两个人都能取出钱，基金剩余-50 */
public class UnsafeBank {

	public static void main(String[] args) {
		
		Account account = new Account(100,"基金");
		
		Drawing Jack = new Drawing(account,50,"Jack");
		Drawing Tom = new Drawing(account,100,"Tom");
		
		Jack.start();
		Tom.start();
		
	}
	
}

/**
 * @author zxy
 * 账户
 */
class Account{
	
	int money;
	String name;
	
	public Account(int money, String name) {
		this.money = money;
		this.name = name;
	}
}

/**
 * @author zxy
 * 银行：模拟取款
 */
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;
	}
	
	/* 取钱 */
	public void run() {
		/* 判断有没有钱 */
		if(account.money-drawingMoney < 0) {
			System.out.println(Thread.currentThread().getName()+
					"钱不够，取不了");
			return;
		}
		
		/* sleep可以放大问题的发生性 */
		/* 模拟延时 */
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		/* 卡内余额=余额-取出钱 */
		account.money -= drawingMoney;
		
		/* 手里的钱 = 原本手里的钱+取出的钱 */
		nowMoney += drawingMoney;
		
		System.out.println(account.name + "余额为" + account.money);
		System.out.println(this.getName() + "手里的钱" + nowMoney);
		
	}
	
}

不安全线程

package Thread;

import java.util.ArrayList;
import java.util.List;

/* 线程不安全的集合 输出小于1000 */
public class UnsafeList {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		
		for(int i = 0; i < 1000; i++) {
			
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}).start();
			
		}
		
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(list.size());
		
	}
	
}

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，即synchronized关键字，它包括两种用法：synchronized方法和synchronized块

public synchronized void method(int args){ }
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
缺陷：若将一个大的方法声明为synchronized将会影响效率
同步块synchronized(Obj){ }
Obj称为 同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法中的同步监视器就是this或者class
同步监视器的执行过程
1. 第一个线程被访问，锁定同步监视器，执行其中代码
2. 第二个线程访问，发现同步监视器被锁定，无法访问
3. 第一个线程访问完毕，解锁同步监视器
4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

将以上三个案例改为安全

package Thread;

/* 加入同步锁，一个一个排队，线程安全 */
public class UnsafeBuyTicket {

	public static void main(String[] args) {
		
		BuyTicket station = new BuyTicket();
		
		new Thread(station,"小王").start();
		new Thread(station,"小李").start();
		new Thread(station,"小张").start();
		
	}
	
}

class BuyTicket implements Runnable{

	private int ticketNum = 10;
	
	/* 外部停止方式 */
	boolean flag = true;
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		while(flag) {
			buy();
		}
		
	}
	
	/* synchronized同步方法，锁的是this */
	public synchronized void buy() {
		
		/* 判断是否有票 */
		if(ticketNum <= 0) {
			
			flag = false;
			return;
			
		}
		
		/* 模拟延时 */
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		/* 买票 */
		System.out.println(Thread.currentThread().getName()+
				"拿到"+ticketNum--);
	}
	
}

package Thread;
/* 锁的对象就是变化的量，需要增删改的对象 */
/* 锁住代码块，线程安全 */
public class UnsafeBank {

	public static void main(String[] args) {
		
		Account account = new Account(100,"基金");
		
		Drawing Jack = new Drawing(account,50,"Jack");
		Drawing Tom = new Drawing(account,100,"Tom");
		
		Jack.start();
		Tom.start();
		
	}
	
}

/**
 * @author zxy
 * 账户
 */
class Account{
	
	int money;
	String name;
	
	public Account(int money, String name) {
		this.money = money;
		this.name = name;
	}
}

/**
 * @author zxy
 * 银行：模拟取款
 */
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;
	}
	
	/* 取钱 */
	public void run() {
		
		/* synchronized默认锁的是this */
		/* 如果对run方法使用，锁的是drawing，故用方法块 */
		synchronized(account) {
			/* 判断有没有钱 */
			if(account.money-drawingMoney < 0) {
				System.out.println(Thread.currentThread().getName()+
						"钱不够，取不了");
				return;
			}
			
			/* sleep可以放大问题的发生性 */
			/* 模拟延时 */
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			/* 卡内余额=余额-取出钱 */
			account.money -= drawingMoney;
			
			/* 手里的钱 = 原本手里的钱+取出的钱 */
			nowMoney += drawingMoney;
			
			System.out.println(account.name + "余额为" + account.money);
			System.out.println(this.getName() + "手里的钱" + nowMoney);
			
		}
		
	}
	
}

package Thread;

import java.util.ArrayList;
import java.util.List;

/* 锁住list，线程安全，输出1000 */
public class UnsafeList {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		
		for(int i = 0; i < 1000; i++) {
			
			new Thread(()->{
				synchronized (list){
					list.add(Thread.currentThread().getName());
				}
				
			}).start();
			
		}
		
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(list.size());
		
	}
	
}