Java 多线程重温Part 2
书接上文:https://blog.csdn.net/asd1358355022/article/details/118885688
8、创建多线程方式三(Callable方式):
import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class CallableTest implements Callable<Object> { @Override //方法可以抛出异常、具有返回值(返回值和Callable的泛型相同) public Object call() throws Exception { int i = 10; Thread.sleep(200); for (int i1 = 0; i1 < i; i1++) { System.out.println(Thread.currentThread().getName() + "---" + i); } return i++; } public static void main(String[] args) { CallableTest callableTest = new CallableTest(); //FutureTask实现了Runnable接口 FutureTask futureTask = new FutureTask<>(callableTest); new Thread(futureTask).start(); try { //获取call方法返回值 Object o = futureTask.get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } }
9、创建多线程方式四(线程池创建方式):
**Executors.newSingleThreadExecutor():**创建一个单线程的线程池,此线程池保证所有任务的执行顺
序按 照任务的提交顺序执行。
适应场景:适用于需要保证任务顺序执行,并且在任意时间点不会有多个线程活动的场景。
**Executors.newFixedThreadPool(int n):**创建固定线程数量的线程池,该线程池中的线程数量保
持不变。当有新任务提交时,线程池中若有空闲线程,则立即执行;若没有,则新的任务会被暂
存在一个任务队列中,待有线程空闲时,便处理任务队列中的任务。
适应场景:适用于为了满足资源管理需求,而需要限制当前线程的数量的应用场景,它适用于负 载比较重的服务器。
**Executors.newCachedThreadPool():**创建一个可以根据实际情况调整线程数量的线程池,线程池中
的线程数量不确定。若有空闲的线程可以复用,则会优先使用可复用的线程;若所有线程都在工
作,又有新的任务提交,则会创建新的线程处理任务,没有个数上限。
适应场景:大小无界的线程池,适用于执行很多的短期任务的小程序,或者负载较轻的服务器。
**Executors.newScheduledThreadPool(int n):**创建一个定长线程池,支持定时及周期性任务执行
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; class RunnableTestV2 implements Runnable{ @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "--" + i); } System.out.println("-------run方法执行-----"); } } public class ThreadPoolTest { public static void main(String[] args) { RunnableTest runnableTest = new RunnableTest(); //创建固定10个数量的线程池 ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i1 = 0; i1 < 10; i1++) { executorService.execute(runnableTest); } //关闭线程池 executorService.shutdown(); } }
10、synchronized特性
先了解下java的内存模型:
Java内存模型规定了所有的变量都存储在主内存中(此处的主内存与物理硬件的主内存类似,只不过虚拟机又做了一个逻辑映射),每条线程还有自己的工作内存,工作内存保存了被线程使用到的变量的主内存副本拷贝,线程对变量的所有操作(读取、赋值)都必须在工作内存中进性,而不能直接读写主内存的变量。线程间变量的传递均需要通过主内存来完成!
主内存和工作内存交互:
lock (由监控器monitor监控,线程独占,作用于主内存【当变量执行lock方法时,会清空此变量的值,lock之前会把主内存的变量刷新到工作内存中】)-> read(将主内存的值读取到工作内存) -> load(将取到的变量值赋值到工作内存的变量副本中) -> use(线程引擎使用当前工作内存的变量值) -> assign(线程引擎将赋好的新值赋赋值到) -> store(把工作内存中改变的新值传送到主内存中) -> write(将主内存中得到的新值赋值到主内存的对应变量中) -> unlock(监控器monitor退出,锁释放状态,后续可北被其他线程所用)
特性一:原子性
原子性:synchronized能保证一个线程拿到锁(monitor监控器作用),其他线程处于阻塞状态,等当前线程执行完,其他线程才能拿到锁权限,进入同步代码块或者同步方法
特性二:可见性
可见性:执行synchronized时,对应原子操作lock,会刷新工作内存中变量的值
特性三:有序性
有序性:jvm执行代码时会发生重排序,只不过同步代码块或者同步方法只有一个线程执行,保证有序性( jvm运行时为了优化会做一些重排,但是在Java中,不管怎么排序,都不能影响单线程程序的执行结果。as-if-serial语义的意思是:不管怎么重排序,单线程程序的执行结果不能被改变。编译器、runtime和处理器都必须遵守as-if-serial语义。所以编译器和处理器不会对存在数据依赖关系的操作做重排序,因为这种重排序会改变执行结果。但是,如果操作之间不存在数据依赖关系,这些操作就可能被编译器和处理器重排序。
特性四:可重入性
代码示例
public class SynchronizedReentrantTest implements Runnable{ @Override public void run() { synchronized (SynchronizedReentrantTest.class){ System.out.println("获取锁+1"); synchronized (SynchronizedReentrantTest.class){ System.out.println("获取锁+1"); } System.out.println("释放锁:锁数量-1"); } System.out.println("释放锁:锁数量-1"); } public static void main(String[] args) { new Thread(new SynchronizedReentrantTest()).start(); new Thread(new SynchronizedReentrantTest()).start(); } }
可重入性:Synchronized的锁对象中有一个计数器(recursions变量),会记录当前线程有几个锁。在执行完一个同步代码块之后会将锁数量-1,直到减为0释放掉这个锁。 可重入性好处:1、避免死锁问题(在获取到锁之后如果再次遇到同步代码块还能获取到锁) 2、更好的代码封装(同步代码块中调用a方法,a方法中也有同步代码块)
特性四:不可中断性
一个线程进入Synchronized获取到锁之后,另外一个线程只能被阻塞处于等待状态,如果锁一直得不到释放,第二个线程会一直等待且不可被中断(在调用中断方法interrupt方法之后依旧为BLOCKED状态)。
代码示例
public class SynchronizedNonInterruptTest{ public static Object object = new Object(); public static void main(String[] args) throws InterruptedException { Runnable runnable = new Runnable() { @Override public void run() { synchronized (object) { try { Thread.sleep(99999999); } catch (InterruptedException e) { e.printStackTrace(); } } } }; Thread thread = new Thread(runnable); thread.start(); Thread.sleep(1000); Thread thread2 = new Thread(runnable); thread2.start(); System.out.println("thread 1 status:"+ thread.getState()); System.out.println("thread 2 status:" + thread2.getState()); //调用中断 thread2.interrupt(); System.out.println("thread 2 status for interrupt:" + thread2.getState()); } }
运行结果:
thread 1 status:TIMED_WAITING thread 2 status:BLOCKED thread 2 status for interrupt:BLOCKED //在调用中断之后依旧是阻塞状态
11、Lock的可中断性和不可中断性
lock锁和synchronized区别
lock是外部接口,synchronized是Java内部关键字。
lock可以响应中断,如果当前持有锁则释放锁,sync不可
lock可以尝试超时获取锁,sync不可
lock可以获知是否有线程在等待当前的锁,sync不可
lock需要手动释放锁,sync自动释放
不可中断性:
代码示例
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockTest { private static Lock reentrantLock = new ReentrantLock(); public static void main(String[] args) throws InterruptedException { Runnable runnable = new Runnable() { @Override public void run() { try { //上锁 reentrantLock.lock(); Thread.sleep(99999999); }catch (Exception e){ e.printStackTrace(); }finally { //解锁 reentrantLock.unlock(); } } }; Thread thread = new Thread(runnable); thread.start(); Thread.sleep(1000); Thread thread2 = new Thread(runnable); thread2.start(); System.out.println("thread 1 status:"+ thread.getState()); System.out.println("thread 2 status:" + thread2.getState()); //调用中断 thread2.interrupt(); System.out.println("thread 2 status for interrupt:" + thread2.getState()); } }
运行结果
thread 1 status:TIMED_WAITING thread 2 status:RUNNABLE thread 2 status for interrupt:WAITING //不可被中断
可中断性
持有锁时可以被interrupt方法中断。
代码示例
import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockTest { private static Lock reentrantLock = new ReentrantLock(); public static void main(String[] args) throws InterruptedException { Runnable runnable = new Runnable() { @Override public void run() { String threadName = Thread.currentThread().getName(); boolean b = false; try { //上锁 b = reentrantLock.tryLock(3, TimeUnit.SECONDS); if (b){ System.out.println(threadName + "获取到锁"); Thread.sleep(99999999); }else { System.out.println(threadName + "没获取到锁。中断,去做其他事情"); } }catch (Exception e){ e.printStackTrace(); }finally { //解锁 if (b) { reentrantLock.unlock(); System.out.println(threadName + "释放锁"); } } } }; Thread thread = new Thread(runnable); thread.start(); Thread.sleep(1000); Thread thread2 = new Thread(runnable); thread2.start(); System.out.println("thread 1 status:"+ thread.getState()); System.out.println("thread 2 status:" + thread2.getState()); thread2.interrupt(); System.out.println("thread2 is Interrupted ?" + thread2.isInterrupted()); } }
运行结果:
Thread-0获取到锁 thread 1 status:TIMED_WAITING thread 2 status:RUNNABLE Thread-0释放锁 Thread-1获取到锁 java.lang.InterruptedException: sleep interrupted at java.lang.Thread.sleep(Native Method) at org.example.LockTest$1.run(LockTest.java:22) at java.lang.Thread.run(Thread.java:748) thread 1 status for interrupt:TERMINATED //睡眠中被中断,其他线程拿到锁