多线程学习笔记（狂神说视频21-28）

CopyOnWriteArrayList

package demo3;

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class TestJUC {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
		for(int i=0;i<10000;i++)
		{
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}).start();
		}
		try {
			Thread.sleep(3000);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		System.out.println(list.size());
	}

}

22死锁

死锁：多个线程互相抱着对方需要的资源，然后形成僵持

package demo4;
//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Makeup g1 = new Makeup(1,"灰姑娘");
		Makeup g2 = new Makeup(1,"白雪公主");
		g1.start();
		g2.start();
	}

}
//口红
class Lipstick{
	
}

//镜子
class Mirror{
	
}

class Makeup extends Thread{
	//需要的资源只有一份,所以用static
	static Lipstick l = new Lipstick();
	static Mirror m = new Mirror();
	
	int choice;//选择
	String girlName;//选择化妆品的人
	Makeup(int choice,String girlName)
	{
		this.choice = choice;
		this.girlName = girlName;
		
	}
	
	@Override
	public void run(){
		//化妆
		try {
			makeup();
		}catch(Exception e)
		{
			e.printStackTrace();
		}
	}
	
	//化妆,互相持有对方的锁，就是需要拿到对方的资源
	private void makeup() throws InterruptedException{
		if(choice==0)
		{
			synchronized(l)//获得口红的锁
			{
				System.out.println(this.girlName+"获得了口红的锁");
				Thread.sleep(1000);
			}
			synchronized(m)//一秒钟后想获得镜子的锁
			{
				System.out.println(this.girlName+"获得镜子的锁");
			}
		}
		else
		{
			synchronized(m)//获得镜子的锁
			{
				System.out.println(this.girlName+"获得了镜子的锁");
				Thread.sleep(2000);
			}
			synchronized(l)//一秒钟后想获得口红的锁
			{
				System.out.println(this.girlName+"获得口红的锁");
			}
		}
		
	}
	
}

运行结果:

Lock锁

package demo4;

import java.util.concurrent.locks.ReentrantLock;

//测试lock锁
public class TestLock {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestLock2 t = new TestLock2();
		new Thread(t).start();
		new Thread(t).start();
		new Thread(t).start();
	}

}
class TestLock2 implements Runnable{
	int ticketNums = 10;
	
	//定义Lock锁
	private final ReentrantLock lock = new ReentrantLock();
	
	@Override
	public void run() {
		while(true)
		{
			try {
				lock.lock();//加锁
				if(ticketNums>0)
				{
					try {
						Thread.sleep(1000);
					}catch(Exception e)
					{
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+" "+ticketNums--);
				}
				else
					break;
			}finally {
				//解锁
				lock.unlock();
			}
			
		}
	}
}

运行结果：

24生产消费者问题

25管程法

package demo4;
//测试：生产者消费者模型-》里哟个缓冲区解决：管程法
//生产者，消费者，长跑，缓冲区
public class TestPC {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SynContainer c = new SynContainer();
		new Productor(c).start();
		new Consumer(c).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 Consumer(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(Exception e) {
				e.printStackTrace();
			}
		}
		//如果没有满，我们就需要丢入产品
		chickens[count] = chicken;
		count++;
		//可以通知消费者了
		this.notifyAll();
	}
	//消费者消费产品
	
	//消费者消费产品
	public synchronized Chicken pop() {
		//判断能否消费
		if(count==0)
		{
			//等待生产者生产，消费者等待
			try {
				this.wait();
			}catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		
		//如果可以消费
		count--;
		Chicken chicken = chickens[count];
		//吃完了，通知生产者生产
		this.notifyAll();
		return chicken;
	}
}

运行结果：

26信号灯法

package demo4;
//测试生产消费者问题2,信号灯法，标志位解决
public class TestPC2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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 Watcher(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(Exception e)
			{
				e.printStackTrace();
			}
		}
		System.out.println("演员表演了"+voice);
		//通知观众观看
		this.notifyAll();
		this.voice = voice;
		this.flag = !this.flag;
	}
	//观众看
	public synchronized void watch() {
		if(flag)
		{
			try {
				this.wait();
			}catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		System.out.println("观看了"+voice);
		//通知演员表演
		this.notifyAll();
		this.flag = !this.flag;
	}
}

运行结果：

27：线程池

package demo4;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//测试线程池
public class TestPool {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.创建线程池
		ExecutorService service = Executors.newFixedThreadPool(10);
		//执行
		service.execute(new MyThread());
		service.execute(new MyThread());
		service.execute(new MyThread());
		service.execute(new MyThread());
		//关闭连接
		service.shutdown();
	}

}
class MyThread implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<2;i++)
		{
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
}

运行结果：

28总结

package demo4;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

//回顾总结线程的创建
public class ThreadNew {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new MyThread1().start();
		new Thread(new MyThread2()).start();
		
		FutureTask<Integer> f = new FutureTask<Integer>(new MyThread3());
		new Thread(f).start();
		try {
			Integer i = f.get();
			System.out.println(i);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		
	}

}
//1.继承Thread类
class MyThread1 extends Thread{
	@Override
	public void run() {
		System.out.println("MyThread1");
	}
}
//2.实现Runnable接口
class MyThread2 implements Runnable{
	@Override
	public void run() {
		System.out.println("MyThread2");
	}
}

//3.实现Callable接口
class MyThread3 implements Callable<Integer>{
	@Override
	public Integer call() throws Exception{
		System.out.println("MyThread3");
		return 100;
	}
}

运行结果：