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 //睡眠中被中断，其他线程拿到锁
