开发者社区> 力不竭战不止> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

每日积累【Day4】Java 多线程重温Part 2

简介: 每日积累【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特性

1.png

先了解下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  //睡眠中被中断,其他线程拿到锁

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
每日积累【Day 6】Java线程池重温 Part 3:线程池原理剖析(Part 1)
每日积累【Day 6】Java线程池重温 Part 3:线程池原理剖析(Part 1)
0 0
Java 多线程重温Part 1 持续补充中
Java 多线程重温Part 1 持续补充中
0 0
java并发编程实践 part 01 --> 线程创建方式
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_26654727/article/details/78013989 最近在尝试重新复习一段关于多线程的使用,同时尝试使用关于markdown编辑器的使用方法,会同步将自己整理的文档放上来。
567 0
Java实现单词计数MapReduce
本文分享实现单词计数MapReduce的方法
0 0
JAVA 实现上传图片添加水印(详细版)(上)
JAVA 实现上传图片添加水印(详细版)
0 0
Java 实现汉字按照首字母分组排序
Java 实现汉字按照首字母分组排序
0 0
Java实现图书管理系统
本篇文章是对目前Java专栏已有内容的一个总结练习,希望各位小主们在学习完面向对象的知识后,可以阅览本篇文章后,自己也动手实现一个这样的demo来加深总结应用已经学到知识并进行巩固。
0 0
+关注
力不竭战不止
本人csdn地址:https://blog.csdn.net/asd1358355022?spm=1000.2115.3001.5343
文章
问答
文章排行榜
最热
最新
相关电子书
更多
JAVA 应用排查全景图
立即下载
Java工程师必读手册
立即下载
Java应用提速(速度与激情)
立即下载