Java学习笔记2——多线程详解

1. 线程简介

程序:静态概念,是指令和数据的有序集合。
进程:动态概念,执行程序的一次执行过程,是系统资源分配的单位。
线程:独立的执行路径,每一个线程都有自己的局部变量表、程序计数器(指向正在执行的指令指针)以及各自的生命周期。

  • 一个进程Process至少有一个线程Thread,线程是CPU调度和执行的单位。
  • 线程运行由调度器安排调度,调度器与操作系统紧密相关,先后顺序不能人为干预。
  • 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程、gc线程。
  • main()称之为主线程,为系统的入口,用于执行整个程序。
  • 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制。
  • 线程会带来额外的开销,如CPU调度时间,并发控制开销。
  • 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致。
  • 线程启动必须在其中一个任务之前,否则线程将永远得不到启动,因为前一个任务永远不会结束。
  • 借助Jconsole或者Jstack命令查看线程。
    在这里插入图片描述

注意:很多多线程是模拟出来的,即在同一CPU下,同一个时间点只执行一个代码,因为切换很快,所以有同时执行的错觉。真正的多线程是指有多个CPU,即多核,如服务器。

2. 线程实现

2.1 线程创建

方法一:继承Thread类

(实现了Runnable接口)
每个线程都有优先权(但最终仍由CPU决定)。每个线程可能也可能不会被标记为守护程序。当在某个线程中运行的代码创建一个新的Thread对象时,新线程的优先级最初设置为等于创建线程的优先级,并且当且仅当创建线程是守护进程时才是守护线程。
不建议使用:避免OOP单继承局限性
实现:将一个类声明为Thread的子类,该子类重写run类的方法Thread,然后分配并启动子类的实例。

public class TestThread extends Thread{
	@override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println("我在看代码");
		}
	}
	public static void main(String[] args) {
		TestThread testThread = new TestThread();
		testThread.start();  // 同时交替进行
		// 线程开启不一定立即执行,由CPU调度
		testThread.run(); // 先调用run方法(错误) 
		for (int i = 0; i < 20; i++) {
			System.out.println("多线程");
		}
	}
}

案例:多线程下载图片
下载commons-io.jar包

public class TestThread extends Thread{
	private String url;
	private String name;
	public TestThread(String url,String name){
		this.url = url;
		this.name = name;
	}
	@override
	public void run(){
		WebDownLoader webDownloder = new WebDownLoader();
		webDownloder.downloder(url,name);
	}
	public static void main(String[] args){
		TestThread t1 = new TestThread("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3403164926,2805624001&fm=26&gp=0.jpg","1.jpg");
		t1.start();
	}
}
class WebDownLoader{
	public woid downloder(String url,String name){
		try{
			FileUtils.copyURLToFile(new URL(url), new File(name));
		}catch(IOException e){
			e.printStackTrace();
			System.out.println("IO异常");
		}
	}
}

方法二:实现Runnable接口

声明实现类Runnable接口,该类重写run方法,通过分配类的实例,在创建Thread时作为参数传递并启动。
启动线程:传入目标对象+Thread对象.start()
推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用

public class TestThread implements Runnable{
	@override
	public void run(){
		for (int i = 0; i < 20; i++){
			System.out.println("代码");
		}
	}
	public static void main(String[] args){
		TestThread testThread = new TestThread();
		
		Thread thread = new Thread(testThread);
		thread.start();
		//new Thread(testThread).start();
		
		for (int i = 0; i < 20; i++) {
			System.out.println("多线程");
		}
	}
}

案例:买火车票

public class TestThread implements Runnable(){
	private int ticketNums = 10;
	@override
	public void run(){
		while (true) {
			if (ticketNums <= 0){
				break;
			}
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getNames()+"拿到了第"+ticketNames--+"票");
		}
	}
	public static void main(String[] args) {
		TestThread ticket= new TestThread();
		new Thread(ticket,"小明").start();
		new Thread(ticket,"老师").start();
		new Thread(ticket,"黄牛党").start();
	}
}

案例:龟兔赛跑

public class Race implements Runnable {
	private static String winner;
	@override
	public void run() {
		for (int i = 0; i <= 100; i++) {
			//模拟兔子休息
			if (Thread.currentThread().getName().equals("兔子") && i%10==0) {
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}			
			//判断比赛是否结束
			boolean glag = gameOver(i);
			if (flag){
				break;
			}
			System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步";
		}
	}
	private boolean gameOver() {
		if (winner != null) {
			return true;
		}{
			if (steps >= 100){
				winner = Thread.currentThread().getName();
				System.out.println("winner is "+winner);
				return true;
			}
		}
		return false;
	}
	public static void main(String[] args) {
		Race race = new Race();
		new Thread(race, "兔子").start();
		new Thread(race, "乌龟").start();
	}
}

方法三:实现Callable接口

实现Callable接口需要返回值类型,重写call方法,需要抛出异常。
优点:1.可以定义返回值;2.可以抛出异常。
创建目标对象
创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行:Future result1 = ser.submit(t1);
获取结果:boolean r1 = result1.get();
关闭服务:ser.shutdownNow();

public class TestCallable implements Callable<Boolean>{
	private String url;
	private String name;
	public TestThread(String url,String name){
		this.url = url;
		this.name = name;
	}
	@Override
	public Boolean call(){
		WebDownLoader webDownloder = new WebDownLoader();
		webDownloder.downloder(url,name);
		return true;
	}
	public static void main(String[] args){
		TestCallable t1 = new TestCallable ("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3403164926,2805624001&fm=26&gp=0.jpg","1.jpg");
		t1.start();
		ExecutorService ser = Executors.newFixedThreadPool(1);
		Future<Boolean> r1= ser.submit(t1);
		boolean rs1 = r1.get();
		ser.shutdownNow();
	}
}
class WebDownLoader{
	public woid downloder(String url,String name){
		try{
			FileUtils.copyURLToFile(new URL(url), new File(name));
		}catch(IOException e){
			e.printStackTrace();
			System.out.println("IO异常");
		}
	}
}

2.2 静态代理

静态代理模式:真实对象和代理对象都要实现同一个接口。代理对象要代理真实角色。
好处:代理对象可以做很多真实对象做不了的事情,真实对象专注做自己的事。

public class Dome1 {
	public static void main(String[] args){
		                    // 代理runnable接口
		// new Thread(()->System.out.println("i love you")).start();
		Company company = new Company(new You());
		company.happymarry();
	} 
}
interface Marry {
	void happymarry();
}
class You implements Marry {
	@Override
	public void happymarry() {
		System.out.println("i am happy!");
	}
}
class Company(You) implements Marry {
	private Marry target; // 传真实对象
	
	public Company(Marry target) {
		this.target = target;
	}
	@Override
	public void happymarry() {
		before();
		this.target.happymarry();
		after();
	}
	public void before() {
		System.out.println("prepare!");
	}
	public void after() {
		System.out.println("we are happy!");
	}
}

2.3 Lambda表达式

其实质属于函数式编程的概念,避免匿名内部类定义过多。
函数式接口的定义:任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。对于函数式接口,可以通过Lambda表达式来创建该接口的对象。

(params) -> expression[表达式]
(params) -> statement[语句]
(params) -> {statements}

a -> System.out.println("i like lambda-->" + a);
new Thread (()->System.out.println("多线程学习。。")).start();

//简化过程:
public class Test {
	//3.静态内部类
	static class Like2 implements iLike{
		@Override
		public void lambda() {
			System.out.println("i like lambda2");
		}
	}
	public static void main(String[] args) {
		iLike like = new Like();
		like.lambda(); //2.
		like = new Like2();
		like.lambda(); //3.

		//4.局部内部类
		class Like3 implements iLike{
			@Override
			public void lambda() {
				System.out.println("i like lambda3");
			}
		like = new Like3();
		like.lambda();//4.
		//5.匿名内部类
		like = new iLike() {//new 接口
			@Override
			public void lambda() {
				System.out.println("i like lambda4");
			}
		};
		like.lambda();
		//6.用Lambda简化
		like = ()->{
			System.out.println("i like lambda5");
		};//只有一行代码可以不用花括号
		like.lambda();
	}
}
//1.定义一个函数式接口
interface iLike{
	void lambda();
}	
//2.实现类
class Like implements iLike{
	@Override
	public void lambda() {
		System.out.println("i like lambda");
	}
}

3. 线程状态

  1. 创建状态
    |启动线程 new
  2. 就绪状态
    |阻塞解除——获得CPU资源
  3. 阻塞状态
  4. 运行状态
    |线程自然执行完毕或外部干涉终止线程
  5. 死亡状态
方法说明
setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象,并执行其他线程
void interrupt()中断线程,别用这个方式
boolean isAlive()测试线程是否处于活动状态

不推荐使用stop、destroy方法(已废弃);推荐线程自己停止下来——建议使用一个标志位进行终止变量,当flag=False,则终止线程运行。

public class Teststop implements Runnable {
	//1.定义标识
	private boolean flag = true;
	@Override
	public void run() {
		//2.使用该标识
		while (flag) {
			System.out.println("run...Thread");
		}
	}
	//3.对外提供方法改变标识
	public void stop(){
		this.flag = false;
	}
}

3.1 线程休眠

  • sleep指定当前线程阻塞的毫秒数,1000毫秒=1秒;
  • sleep存在异常InterruptedException;
  • sleep时间达到后线程进入就绪状态;
  • sleep可以模拟网络延时、倒计时等;
  • 每一个对象都有一个锁,sleep不会释放锁。
//模拟倒计时
public class Test {
	public static void main(String[] args){
		Date statTime = new Date(System.currentTimeMillis());
		try {
			System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
			tenDown();
			statTime = new Date(System.currentTimeMillis());//更新时间
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public static void tenDown() throws InterruptedException {
		int num = 10;
		while (true) {
			Thread.sleep(1000);
			System.out.println(num--);
			if (num == 0){
				break;
			}
		}
	}
}

3.2 线程礼让

让当前正在执行的线程暂停,但不阻塞,将线程从运行状态转为就绪状态,让CPU重新调度,礼让不一定成功,看CPU心情。

public class Test {
	public static void main(String[] args) {
		MyYield myyield = new MyYield();
		new Thread(myyield,"a").start();
		new Thread(myyield,"b").start();
	}
}
class MyYield implements Runnable{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"线程执行");
		Thread.yield();
		System.out.println(Thread.currentThread().getName()+"线程停止执行");
	}
}

3.3 多线程强制执行join

Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞,类似于插队。

public class Test implements Runnable{
	public static void main(String[] args) throws InterruptedException {
		Test test = new Test();
		Thread thread = new Thread(test);
		thread.start();
		for (int i = 0; i < 100; i++) {
			if (i == 50){
				thread.join();
			}
			System.out.println("main...." + i);
		}
	}
	@Override 
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("join..." + i);
		}
	}
}

3.4 线程状态观测

Thread.State

  • NEW:尚未启动的线程
  • RUNNABLE:在JVM中执行的线程
  • BLOCKED:被阻塞等监视器锁定的线程
  • WAITING:正在等待另一个线程执行特定动作的线程
  • TIMED WAITING:正在等待另一个线程执行动作达到指定等待时间的线程
  • TERMINATED:已退出的线程
public class Test {
	public static void main(String[] args) {
		Thread thread = new Thread(()->{
			for (int i = 0; i < 5; i++) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e){
					e.printStackTrace();
				}
			}
			System.out.println("/");
		});
		Thread.State state = thread.getState();
		System.out.println(state);//NEW
		thread.start();
		state = thread.getState();
		System.out.println(state);//RUN
		while (state != Thread.State.TERMINATED){//只要线程不终止,一直输出
			Thread.sleep(1000);
			state = thread.getState();
			System.out.println(state);
		}
	}
}

3.5 线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示,范围从1-10.

  • Thread.MIN_PRIORITY = 1;
  • Thread.MAX_PRIORITY = 10;
  • Thread.NORM_PRIORITY = 5;

使用以下方式改变或获取优先级getPriority()、setPriority(int xxx)。
先设置优先级再启动。性能倒置:优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用了,这都是看CPU的调度。

3.6 守护线程daemon

线程分为用户线程和守护线程。虚拟机必须确保用户线程执行完毕。虚拟机不用等待守护线程执行完毕,如后台记录操作日志、监控内存、垃圾回收等。

public class Test {
	public static void main(String[] args) {
		God god = new God();
		You you = new You();
		Thread thread = new Thread(god);
		thread.setDaemon(true);//默认是False为用户线程,正常线程都是用户线程
		thread.start();
		new Thread(you).start();
	}
}
class God implements Runnable{
	@Override
	public void run(){
		while (true) {
			System.out.println("god blessing you");
		}
	}
}
class You implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 36500; i++){
			System.out.println("happy living");
		}
		System.out.println("====goodbye:world!====");
	}

4. 线程同步

4.1 线程同步

并发:同一个对象被多个线程同时操作。
线程同步是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待使用后释放锁即可。
存在以下问题:

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起;
  • 在多线程竞争下,加锁、释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题。

synchronized关键字,它包括两种用法:synchronized方法和synchronized块。

  1. synchronized方法:
public synchronized void method(int args){}
  1. synchronized块:
    synchronized(Obj){}
    Obj称之为同步监视器,可以是任何对象,推荐使用共享资源作为同步监视器。同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class。
    缺陷:若将一个大的方法申明为synchronized将会影响效率。

案例:买火车票

public class Test {
	public static void main(String[] args){
		BuyTicket station = new BuyTicket();
		new Thread(station,"a").start();
		new Thread(station,"b").start();
		new Thread(station,"c").start();
}
class BuyTicket implements Runnable{
	private int ticketNum = 10;//保证数据对象只能被方法访问,get/set
	boolean flag = true;
	@Override
	public void run(){
		while (flag){//线程停止
			try{
				buy();
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		}
	}
	//同步方法,锁的是this
	public synchronized void buy() throws InterruptedException {
		if (ticketNum <= 0){
			flag = false;
			return;
		}
		Thread.sleep(100);//模拟延时可以放大问题的发生性
		System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
	}
}

4.2 JUC

import java.util.concurrent.CopyOnWriteArrayList;
public class Test {
	public static void main(String[] args){
		CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
		for (int i = 0; i < 10000; i++) {
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}).start();
		}
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(list.size());
	}
}

4.3 死锁

导致两个或者多个线程都在等待对方释放资源,都停止执行的情形,某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。

产生死锁的四个必要条件:(想办法避免其中一个或多个)

  • 互斥条件:一个资源每次只能被一个进程使用;
  • 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放;
  • 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺;
  • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

4.4 Lock(锁)

从JDK5.0开始,Java提供了更强大的线程同步机制——通过显式定义同步锁Lock对象来实现同步。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
可重入锁ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁(synchronized是隐式锁,出了作用域自动释放)。
异同点:Lock只有代码块锁,synchronized有代码块锁和方法锁。使用Lock锁,JVM花费较少的时间来调度线程,性能更好,有更多扩展性(子类)。
优先顺序:Lock>同步代码块(已经进入方法体,分配了相应资源)>同步方法

class A {
	private final ReentrantLock lock = new ReentrantLock();
	public void m(){
		lock.lock();
		try{
			//保证线程安全的代码
		}
		finally{
			lock.unlock();
			//如果同步代码有异常,需要unlock写入finally语句块
		}
	}
}

5. 线程通信问题

生产者消费者问题:生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件。
synchronized可阻止并发更新同一个共享资源,实现同步,但不能实现线程之间的消息传递。

方法名作用(object类的方法,仅在同步方法或同步代码块中使用,否则抛出异常)
wait()表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁
wait(long timeout)指定等待的毫秒数
notify()唤醒一个处于等待状态的线程
notifyAll()唤醒同一个对象上所有调用wait()方法的线程,优先级别高的线程优先调度

解决方法1:管程法——缓冲区

public class Test{
	public static void main(String[] args){
		SynContainer container = new SynContainer();
		new Productor(container).start();
		new Consumer(container).start();	
	}
}
class Productor extends Thread{
	SynContainer container;
	public Productor(SynContainer container){
		this.container = container;
	}
	@Override
	public void run(){
		for (int i = 0; i < 100; i++){
			container.push(new chicken(i));
			System.out.println("生产了"+i+"只鸡");
		}
	}
}
class Consumer extends Thread{
	SynContainer container;
	public Productor(SynContainer container){
		this.container = container;
	}
	@Override
	public void run(){
		for (int i=0; i<100;i++){
			System.out.println("消费了"+container.pop().id+"只鸡");
		}
	}
}
class Chicken{
	int id;
	public Chicken(int id){
		this.id = id;
	}
}
class SynContainer{
	Chicken[] chickens = new Chicken[10];//需要一个容器大小
	int count = 0;//容器计数器
	//生产者放入
	public synchronized void push(Chicken chicken){
		//如果容器满了
		if (count==chickens.length){
			try {
				this.wait();//通知消费消费,生产者等待
			}catch (InterruptedException e){
				e.ptintStackTrace();
			}
		}
		chickens[count] = chicken;//如果容器没有满
		count++;
		this.notifyAll();//通知消费者消费
	}
	//消费者消费
	public synchronized Chicken pop(){
		if (count==0){
			try{//通知生产
				this.wait();
			}catch (InterruptedException e){
				e.printStackTrace();
			}
		}
		count--;
		Chicken chicken = chichens[count];
		this.notifyAll();
		return chicken;
}

解决方法2:信号灯法——标志位

public class Test(){
	public static void main(String[] args){
		Tv tv = new TV();
		new Player(tv).start();
		new Watcher(tv).start();
	}
}
class Player extends Thread{
	TV tv;
	public Player(TV tv){
		this.tv = tv;
	}
	@Override
	public void run(){
		for (int i=0; i<20; i++){
			if(i%2==0){
				this.tv.play("快乐大本营");
			}else{
				this.tv.play("天天向上");
			}
		}
	}
}
class Watcher extends Thread{
	TV tv;
	public Player(TV tv){
		this.tv = tv;
	}
	@Override
	public void run(){
		for (int i=0; i<20; i++){
			tv.watch();
		}
	}
}
class TV{
	String voice;
	boolean flag = true;
	public synchronized void play(String voice){
		if(!flag){
			try{
				this.wait();
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.println("演员表演了"+voice);
		this.voice = voice;
		this.flag = !this.flag;
	}
	public synchronized void watch(){
		if(flag){
			try{
				this.wait();
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.println("观众观看了"+voice);
		this.notifyAll();
		this.flag = !this.flag;
	}
}

6. 高级主题

经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
线程池:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁,实现重复利用。
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止

JDK5.0提供了线程池相关API:

  • ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
    void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
    Futuresubmit(Callabletask):执行任务,有返回值,一般又来执行Callable
    void shutdown():关闭连接池
  • Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test{
	public static void main(String[] args){
		//1.创建服务,创建线程池:参数为线程池大小
		ExecutorService service = Executors.newFixedThreadPool(10);
		//2.执行
		service.execute(new MyThread());
		service.execute(new MyThread());
		service.execute(new MyThread());
		//3.关闭链接
		service.shutdown();
	}
}
class MyThread implements Runnable{
	@Override
	public void run(){
		for(int i = 0; i<100; i++){
			System.out.println(Thread.currentThread().getName()+i);
		}
	}
}

Semaphore类——限制线程并发的数量,否则CPU很快耗尽

private Semaphore semaphore = new Semaphore(permits:1);//构造函数参数permits是许可的意思,代表同一时间内,最多允许多少个线程同时执行acquire()和release()之间的代码。permits值如果大于1,并不能保证线程安全性,可能会出现多个线程共同访问实例变量,出现脏数据
public void testMethod() {
	try {
		semaphore.acquire();//无参方法,使用一个许可
		//semaphore.acquire(int permits);  每调用1次此方法,就使用x个许可
		//semaphore.acquireUninterruptibly();  在等待许可的情况下不允许中断,如果成功获得锁,则取得指定的permits许可个数
		System.out.println(Thread.currentThread().getName() + "begin timer=" + System.currentTimeMillis());
		Thread.sleep(5000);
		System.out.ptintln(Thread.currentThread().getName() + "end timer=" + System.currentTimeMillis());
		semaphore.release();
		//调用release()或release(int)可以动态增加permits的个数
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}
//availablePermits()返回此Semaphore对象中当前可用的许可数,用于调试
//drainPermits()获取并返回立即可用的所有许可个数,并将可用许可置0
//getQueueLength()取得等待许可的线程个数
//hasQueuedThreads()判断有没有线程在等待这个许可

有些时候,获得许可的顺序与线程启动的顺序有关,这时信号量就要分为公平与非公平的。所谓的公平信号量是获得锁的顺序与线程启动的顺序有关,但不代表100%地获得信号量,仅仅是在概率上能得到保证。而非公平信号量就是无关的了。

private boolean isFair = false;
private Semaphore semaphore = new Semaphore(permits:1, isFair);
  • 无参方法tryAcquire()的作用是尝试地获得1个许可,如果获取不到则返回false,与if结合,具有无阻塞地特点,使线程不至于在同步处一直持续等待的状态。
  • 有参方法tryAcquire(int permits)的作用是尝试地获得x个许可,如果获取不到则返回false。
  • 有参方法tryAcquire(int long timeout, TimeUnit unit)的作用是在指定的时间内尝试地获得1个许可,如果获取不到则返回false。 如tryAcquire(3, TimeUnit.SECONDS)
  • 有参方法tryAcquire(int permits, int long timeout, TimeUnit unit)的作用是在指定的时间内尝试地获得x个许可,如果获取不到则返回false。
private Semaphore semaphore = new Semaphore(permits:1);
public void testMethod() {
	if (semaphore.tryAcquire()) {
		System.out.println(Thread.currentThread().getName() + "begin timer=" + System.currentTimeMillis());
		Thread.sleep(5000);
		System.out.ptintln(Thread.currentThread().getName() + "end timer=" + System.currentTimeMillis());
		semaphore.release();
	} else { 
		System.out.println("ThreadName=" + Thread.currentThread().getName() + "未成功进入!");
	}
}
  • 多进路,多处理,多出路(多个线程同时处理自己的任务)
  • 多进路,单处理,多出路(允许多个线程同时处理任务,但执行任务的顺序却是同步的/阻塞的)——加入ReentrantLock对象保证同步性
private Semaphore semaphore = new Semaphore(3);
private ReentrantLock lock = new ReentrantLock();
public void testMethod() {
	try {
		semaphore.acquire();
		System.out.println("ThreadName=" + Thread.currentThread().getName() + "准备");
		lock.lock();
		System.out.println("begin hello " + System.currentTimeMillis());
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName() + "打印" + (i+1));
		}
		System.out.println(" end hello" + System.currentTimeMillis());
		lock.unlock;
		semaphore.release();
		System.out.println("ThreadName=" + Thread.currentThread().getName() + "结束");
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

使用Semaphore创建字符串池:同时有若干个线程可以访问池中的数据,但同时只有一个线程可以取得数据,使用完毕后再放回池中。

package tools;
import java.util.ArrayList;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ListPool {
	private int poolMaxSize = 3;
	private int semaphorePermits = 5;
	private List<String> list = new ArrayList<String>();
	private Semaphore concurrencySemaphore = new Semaphore(semaphorePermits);
	private ReentrantLock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	public ListPool() {
		super();
		for (int i = 0; i < poolMaxSize; i++) {
			list.add("zzz" + (i + 1));
		}
	}
	public String get() {
		String getString = null;
		try {
			concurrencySemaphore.acquire();
			lock.lock();
			while(list.size() == 0) {
				condition.await();
			}
			getString = list.remove(0);
			lock.unlock();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return getString;
	}
	public void put(String stringValue) {
		lock.lock();
		list.add(stringValue);
		condition.signalAll();
		lock.unlock();
		concurrencySemaphore.release();
	}
}
package extthread;
import tools.ListPool;
public class MyThread extends Thread {
	private ListPool listPool;
	public MyThread(ListPool listPool) {
		super();
		this.listPool = listPool;
	}
	@Override
	public void run() {
		for (int i = 0; i < Integer.MAX_VALUE; i++) {
			String getString = listPool.get();
			System.out.println(Thread.currentThread().getName() + "取得值" + getString);
			listPool.put(getString);
		}
	}
}
package test;
import tools.ListPool;
import extthread.MyThread;
public class Run {
	public static void main(String[] args) {
		ListPool pool = new ListPool();
		MyThread[] threadArray = new MyThread[12];
		for (int i = 0; i < threadArray.length; i++) {
			threadArray[i] = new MyThread(pool);
		}
		for (int i = 0; i < threadArray.length; i++) {
			threadArray[i].start();
		}
	}
}

多生产者/多消费者模式:

package service;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Conditon;
import java.util.concurrent.locks.ReentrantLock;
public class RepastService {
	volatile private Semaphore setSemaphore = new Semaphore(10);//厨师
	volatile private Semaphore getSemaphore = new Semaphore(20);//就餐
	volatile private ReentrantLock lock = new ReentrantLock();
	volatile private Condition setCondition = lock.newCondition();
	volatile private Condition getCondition = lock.newCondition();
	//producePosition变量的含义是最多只有4个盒子存放菜品
	volatile private Object[] producePosition = new Object[4];
	private boolean isEmpty() {
		boolean isEmpty = true;
		for (int i = 0; i < producePosition.length; i++) {
			if (producePosition[i] != null) {
				isEmpty = false;
				break;
			}
		}
		if (isEmpty == true) {
			return true;
		} else {
			return false;
		}
	}
	private boolean isFull() {
		boolean isFull = true;
		for (int i = 0; i < producePosition.length; i++) {
			if (producePosition[i] == null) {
				isFull = false;
				break;
			}
		}
		return isFull;
	}
	public void set() {
		try {
			setSemaphore.acquire();//允许同时最多有10个厨师生产
			lock.lock();
			while (isFull()) {
				setCondition.await();
			}
			for (int i = 0; i < producePosition.length; i++) {
				if (producePosition[i] == null) {
					producePosition[i] = "数据";
					System.out.println(Thread.currentThread().getName() + "生产了" + producePosition[i]);
					break;
				}
			}
			getCondition.signalAll();
			lock.unlock();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			setSemaphore.release();
		}
	}
	public void get() {
		try {
			getSemaphore.acquire();
			lock.lock();
			while (isEmpty()) {
				getCondition.await();
			}
			for (int i = 0; i < producePosition.length; i++) {
				if (producePosition[i] != null) {
					System.out.println(Thread.currentThread().getName() + "消费了" + producePosition[i]);
					producePosition[i] = null;
					break;
				}
			}
			setCondition.signalAll();
			lock.unlock();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			getSemaphore.release();
		}
	}
}				
package test.run;
import service.RepastService;
import extthread.ThreadC;
import extthread.ThreadP;
public class Run {
	public static void main(String[] args) throws InterruptedException {
		RepastService service = new RepastService();
		ThreadP[] arrayP = new ThreadP[60];
		ThreadC[] arrayC = new ThreadC[60];
		for (int i = 0; i < 60; i++) {
			arrayP[i] = new ThreadP(service);
			arrayC[i] = new ThreadC(service);
		}
		Thread.sleep(2000);
		for (int i = 0; i < 60; i++) {
			arrayP[i].start();
			arrayC[i].start();
		}
	}
}

Exchanger类——2个线程之间传递任意数据类型的数据

exchange()方法具有阻塞的特色,被调用后等待其他线程来取得数据,如果没有其他线程取得数据,则一直阻塞等待。

package extthread;
import java.util.concurrent.Exchanger;
public class ThreadA extends Thread {
	private Exchanger<String> exchanger;
	public ThreadA(Exchanger<String> exchanger) {
		super();
		this.exchanger = exchanger;
	}
	@Override
	public void run() {
		try {
			System.out.println("在线程A中得到线程B的值=" + exchanger.exchange("中国人A"));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}		

CountDownLatch类——控制线程执行任务时机,使线程以”组团“的方式执行任务

计数无法被重置,如果需要重置计数,用CyclicBarrier类。

package service;
import java.util.concurrent.CountDownLatch;
public class MyService {
	private CountDownLatch down = new CountDownLatch(1);//创建1个计数的CountDownLatch类的对象
	public void testMethod() {
		try {
			System.out.println("A");
			down.await();//判断计数是否为0,不为0则呈等待状态
			System.out.println("B");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public void downMethod() {
		System.out.pritnln("X");
		down.countDown();//将计数减1,减为0等待线程继续运行
	}
}

裁判等全部运动员:

package extthread;
import java.util.concurrent.CountDownLatch;
public class MyThread extends Thread {
	private CountDownLatch maxRuner;
	public MyThread(CountDownLatch maxRuner) {
		super();
		this.maxRunner = maxRuner;
	}
	@Override
	public void run() {
		try {
			Thread.sleep(2000);
			maxRuner.countDown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
package test.run;
import java.util.concurrent.CountDownLatch;
import extthread.MyThread;
public class Run {
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch maxRuner = new CountDownLatch(10);
		MyThread[]  tArray = new MyThread[Integer.parseInt(""+maxRuner.getCount())];//获取当前计数值
		for (int i = 0; i < tArray.length; i++) {
			tArray[i] = new MyThread(maxRuner);
			tArray[i].setName("线程"+(i+1));
			tArray[i].start();
		}
		maxRuner.await();
		System.out.println("都回来了");
	}
}	

CyclicBarrier类——阶段性同步,实现线程一起做任务

允许一组线程互相等待,直到到达某个公共屏障点。
CountDownLatch类与CyclicBarrier类的区别:1)CountDownLatch作用:一个线程或者多个线程,等待另外一个线程或多个线程完成某个事情之后才能继续执行;2)CyclicBarrier的作用:多个线程之间相互等待,任何一个线程完成之前,所有的线程都必须等待,即“多个线程之间”任何一个线程没有完成任务,则所有的线程必须等待。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值