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

最新推荐文章于 2024-09-20 15:32:13 发布

RuiZ-4009

最新推荐文章于 2024-09-20 15:32:13 发布

阅读量309

点赞数

分类专栏：编程语言文章标签： java 多线程并发编程

本文链接：https://blog.csdn.net/qq_42461714/article/details/113918356

版权

编程语言专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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. 线程状态

创建状态
|启动线程 new
就绪状态
|阻塞解除——获得CPU资源
阻塞状态
运行状态
|线程自然执行完毕或外部干涉终止线程
死亡状态

方法	说明
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块。

synchronized方法：

public synchronized void method(int args){}

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的作用：多个线程之间相互等待，任何一个线程完成之前，所有的线程都必须等待，即“多个线程之间”任何一个线程没有完成任务，则所有的线程必须等待。