Java高级多线程笔记

最新推荐文章于 2024-07-04 19:46:30 发布

Willing卡卡

最新推荐文章于 2024-07-04 19:46:30 发布

阅读量274

点赞数

分类专栏： JAVA 文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_42601136/article/details/106988281

版权

JAVA 专栏收录该内容

23 篇文章 5 订阅

订阅专栏

Java高级多线程笔记

引言：

本文主要分享了多线程中的线程池概念（原理以及咋获取线程池）、Callable接口、Future接口、线程的同步以及异步、ReentrantLock（重入锁）、ReentrantRaedWriteLock（读写锁）

Java多线程超详细笔记：分享了多线程的实现方式、7种状态、线程安全的两种解决方案以及死锁、生产者消费者问题；
Java中线程安全的集合：分享了Collection体系集合下除了Vector以外的线程安全集合，包括：Collection中的安全工具方法、CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap、Queue接口

1. 线程池

池就是为了提供复用性，给出一个池实现复用；比如打客服电话，如果该客服占线需要等待，直到你之前的所有排在该客服的客户都咨询完你才可以咨询；客服这就相当于一个池，每天会接不同的电话而不是一个；

1.1 线程池引入

现有问题：

线程是宝贵的内存资源、单个线程约占1MB空间，过分分配易造成内存溢出。

频繁的创建及销毁线程会增加虚拟机回收频率、资源开销、造成程序性能下降。

线程池：

线程是容器，可设定线程分配的数量上限也就是同一时间并发执行的线程的个数。
将预先创建的线程对象存入池中，并实现重用线程池中的线程对象。
可以避免频繁的创建和销毁。

1.2 线程池原理

将任务提交给线程池，由线程池分配线程、运行任务、并在当前任务结束后复用线程。

在这里插入图片描述

如：有三个线程池，四个等待对象；先执行三个，当这三个中的一个执行完毕后空出线程池位置，第四个开始执行。

1.3 获取线程池

常用的线程池接口和类：在java.util.concurrent;包内。

Executor：线程池的顶级接口，执行已经提交的Runnable对象。
ExecutorService：线程池接口，可通过**submit(Runnable task)**提交任务代码。
Executors工厂类：通过此类可以获得一个线程池
通过newFixedThreadPool(int nThreads)：获取固定数量的线程池。参数：指定线程池中线程的数量。
通过newCachedThreadPool()：获得动态数量的线程池，如不够则创建新的，没有上限。

public class TestThreadPool {
	public static void main(String[] args) {
	//线程池(引用)   ---->Executors工具类(工厂类)
	ExecutorService es =  Executors.newFixedThreadPool(3);//手动限定线程池里的线程数量3。
	//	ExecutorService es = Executors.newCachedThreadPool();//动态数量的线程池
		//1.创建任务对象
		MyTask task = new MyTask();
		//2.将任务提交到线程池，由线程池调度、执行
		es.submit(task);//Runnable类型的对象
		es.submit(task);
		es.submit(task);
		es.submit(task);
		es.submit(task);
	}
}
//线程任务
class MyTask implements Runnable{
	public void run() {
		for(int i = 1;i<=5;i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

运行结果：
pool-1-thread-1:1
pool-1-thread-1:2
pool-1-thread-1:3
pool-1-thread-3:1
pool-1-thread-3:2
pool-1-thread-3:3
pool-1-thread-3:4
pool-1-thread-3:5
pool-1-thread-2:1
pool-1-thread-2:2
pool-1-thread-3:1
pool-1-thread-1:4
pool-1-thread-1:5
pool-1-thread-1:1
pool-1-thread-1:2
pool-1-thread-1:3
pool-1-thread-1:4
pool-1-thread-1:5
pool-1-thread-3:2
pool-1-thread-3:3
pool-1-thread-3:4
pool-1-thread-2:3
pool-1-thread-2:4
pool-1-thread-2:5
pool-1-thread-3:5

以上程序是获取固定数量的线程池，由运行结果可以看出线程3最先执行完，之后有开始从1执行，实现了复用；
获取动态数量的线程池可以自动添加线程池，对内存要求较高；

2. Callable接口

JDK5之后加入，与Runnable接口类似都是为了变成任务被线程执行的对象，实现之后代表一个线程任务。Callable具有泛型返回值、可以声明异常，Runnable不行，没有返回值且无法抛出有返回值的异常。

Public interface Callable< V >{//V：value

Public V call() throws Exception;//计算结果，如无法计算则抛出

}

public class TestCallable {
	public static void main(String[] args) {
		ExecutorService es =  Executors.newFixedThreadPool(3);
		
		MyTask task = new MyTask();
		
		es.submit(task);
	}
}
class MyTask implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		for(int i = 1;i<=10;i++) {
			if(i ==5) {
				Thread.sleep(3000);
			}
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
		return null;
	}
}

3. Future接口

异步接收ExecutorServices.submit()：所返回的状态结果，当中包含了call()返回值。

V get()：以阻塞形式等待Future中的异步处理结果（call()的返回值）

需求：

使用两个线程，分别计算1_50，51100的和，进行相加

public class TestFuture {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService es =  Executors.newFixedThreadPool(2);
		MyCall mc = new MyCall();
		MyCall2 mc2 = new MyCall2();
		//通过submit执行提交的任务，Future接受返回的结果
		Future<Integer> result = es.submit(mc);
		Future<Integer> result2 = es.submit(mc2);
		//通过Future的get方法，获得线程执行完毕后的结果
		Integer value =  result.get();
		Integer value2 = result2.get();
		
		System.out.println(value+value2);
	}
}
//计算1~50的和
class MyCall implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		Integer sum = 0;
		for(int i = 1;i<=50;i++) {
			sum = sum + i;
		}
		return sum;
	}
}
//计算51~100的和
class MyCall2 implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		Integer sum = 0;
		for(int i =51;i<=100;i++) {
			sum = sum + i;
		}
		return sum;
	}
}

4. 线程的同步异步

4.1 线程同步

形容一次方法调用，同步一旦开始，调用者必须等待该方法返回，才能继续。

主线程调用m1()方法，优先执行完m1()方法回到主线程调用m2()方法，优先执行完m2()方法回到主线程调用m3()方法，m3方法执行完毕后回到主线程结束

单条执行路径

4.2 线程异步

形容一次方法调用，异步一旦开始，像是一次消息传递，调用者告知之后立刻返回。二者竞争时间片，并发执行；

主线程开始执行，告知m1之后回到主线程，m1也开始执行，各执行各的，二者共同竞争时间片；

多条执行路径

5. Lock接口

JDK5提供了一个比synchronized更广泛的锁定操作（接口：Lock)，可以清晰的看到在哪里加了锁；

public void lock()：加锁
boolean tryLock()//尝试获取锁（成功返回true失败false，不会阻塞）仅在空闲时候才获取锁
public void unlock()：试图释放锁

重入锁

也称递归锁，最多支持同一个线程发起的2147483648个递归锁，超过此限制就会抛出error错误；

Lock无法实例化只能借助子实现类：ReentrantLock可重入锁在 java.util.concurrent.locks包下；

public class TestLocks {
	public static void main(String[] args) {
		Test obj = new Test();//加锁
		Thread t1 = new Thread(new MyTask(obj));
		Thread t2 = new Thread(new MyTask2(obj));
		t1.start();
		t2.start();
	}
}
class Test{
	//创建Lock锁对象
	Lock lock = new ReentrantLock();
	public void method() {
		System.out.println(Thread.currentThread().getName()+"进入到上锁的方法里");
		try {
			//显示的写上 在此处获得锁
			lock.lock();
			try{
				Thread.sleep(3000);
			}catch (InterruptedException e) {
				e.printStackTrace();
		}
			System.out.println(Thread.currentThread().getName()+"退出了上锁的方法里");
		}finally {
			//显示的写上，此处释放锁
			lock.unlock();
		}
	}
}
class MyTask implements Runnable{
	Test obj;//共享资源对象
	public MyTask(Test obj) {
		this.obj = obj;
	}
	public void run() {
		obj.method();
	}
}
class MyTask2 implements Runnable{
	Test obj;//共享资源对象
	public MyTask2(Test obj) {
		this.obj = obj;
	}
	public void run() {
		obj.method();
	}
}

运行结果：
Thread-0进入到上锁的方法里
Thread-1进入到上锁的方法里
Thread-0退出了上锁的方法里
Thread-1退出了上锁的方法里

谁先退出谁先执行，如果没有lock.unlock();则不会释放锁；

注：

当使用Lock时，需要明确的写上锁和释放锁
为了避免拿到锁的线程在运行时出现异常，导致程序终止没有释放锁；应用try{}finally{}保证最后会释放锁。
设置正确的出口，使得每把锁都释放，否则会出现（StackOverflowError内存溢出错误）

6. 读写锁

ReentrantRaedWriteLock：

一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁。
支持多次分配读锁，使多个读操作可以并发执行。

读锁：ReadLock

写锁：WriteLock

在读操作远远高于写操作的环境中，可在保障线程安全的情况下，提高运行效率；

isShutdown()：如果程序关闭返回true

isTerminated()：如果关闭后所有任务都完成，返回true

shutdown()：启动一次顺序关闭，执行以前提交的任务，不接受新任务

public class TestReadWriteLock {
	public static void main(String[] args) {
		Student stu = new Student();//共享资源对象
		ExecutorService es = Executors.newFixedThreadPool(20);//20个线程池
		WriteTask write = new WriteTask(stu);//写线程任务
		ReadTask read = new ReadTask(stu);//读线程任务
		long start = System.currentTimeMillis();//开始时间  毫秒值
		es.submit(write);
		es.submit(write);
		
		for(int i =1;i<=18;i++) {
			es.submit(read);
		}
 		es.shutdown();//停止线程池，但不停止已经提交的任务
		while(true) {
			System.out.println("结束了吗？");
			if(es.isTerminated() == true) {//线程池里的任务都执行完毕了
				break;
			}
		}
		
		long end = System.currentTimeMillis();//结束时间
		System.out.println(end - start);
	}
}
//写
class WriteTask implements Callable{
	Student stu;
	public WriteTask(Student stu) {
		this.stu = stu;
	}
	@Override
	public Object call() throws Exception {
		stu.setAge(100);
		return null;
	}
}
//读
class ReadTask implements Callable{
	Student stu;
	public ReadTask(Student stu) {
		this.stu = stu;
	}
	@Override
	public Object call() throws Exception {
		stu.getAge();
		return null;
	}
}
class Student{
	private int age;
	 //Lock lock = new ReentrantLock();//重入锁
	ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();//有两把锁
	ReadLock read = rrwl.readLock();//读锁
	WriteLock write = rrwl.writeLock();//写锁
	//赋值---写操作
	public void setAge(int age) {
		write.lock();
		try { 
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.age = age;
		}finally {
			write.unlock();
		}
	}
	//取值---读操作
	public int getAge() {
		read.lock();
		try {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			return this.age;
		}finally {
			read.unlock();
		}
	}
}

结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
结束了吗？
3013

使用Lock写2秒，读18秒
使用ReentrantRaedWriteLock，2秒写1秒读，共三秒如上，因为读操作时是异步的

互斥规则：

写-写：互斥、阻塞；

读-写：互斥、读阻塞写，写阻塞读；

读-读：不互斥，不阻塞；

Willing卡卡

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java高级多线程笔记

本文主要分享了多线程中的线程池概念（原理以及咋获取线程池）、Callable接口、Future接口、线程的同步以及异步、ReentrantLock（重入锁）、ReentrantRaedWriteLock（读写锁）
复制链接

扫一扫