每日积累【Day4】Java 多线程重温Part 2-阿里云开发者社区

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状态）。

代码示例

运行结果：

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