Java多线程学习2

最新推荐文章于 2024-04-27 17:30:34 发布

隔壁拓海老湿

最新推荐文章于 2024-04-27 17:30:34 发布

阅读量120

点赞数

文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/SuzukiTakumiSama/article/details/128448339

版权

1.基础篇。

……上一篇地址：Java多线程学习1_隔壁拓海老湿的博客-CSDN博客java提供了丰富的多线程操作，直接使用Java.Lang.Concurrent包下的Api，即可开启使用Java提供的多线程功能。https://blog.csdn.net/SuzukiTakumiSama/article/details/128421450?spm=1001.2014.3001.5502

1.3.线程安全，锁，synchronized，ReentranLock，自旋锁，原子类，CAS。

1.3.1.锁，保证线程安全，实现共享数据同一时间只能一个线程访问，解决了并发修改的问题。底层原理，通过添加一个Monitor管程保证改类或对象线程访问的唯一性，synchronized本质上和ReentranLock一样。都是通过管程Monitor保证线程安全。弊端是悲观锁，导致性能大幅度下降。

    private  int ticket = 1000;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {

        while (true){
            try {
//                2.调用Lock
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("票为" + ticket + "号" + "线程为 " + Thread.currentThread().getName());
                    ticket--;
                } else {
                    break;
                }
            } finally {
//                调用解锁
                lock.unlock();

            }

        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                20
                , 80
                , 3000
                , TimeUnit.MILLISECONDS
                , new ArrayBlockingQueue<Runnable>(10)
                , Executors.defaultThreadFactory()
                , new ThreadPoolExecutor.AbortPolicy()
        );

        while (true){
            try {
                TimeUnit.MILLISECONDS.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            CompletableFuture.runAsync(new DemoRun(),threadPoolExecutor);
        }

    }
}
class DemoRun implements Runnable{
    public static void show(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread.currentThread().getName() = " + Thread.currentThread().getName());
    }

    @Override
    public void run() {
        show();
    }
}

1.3.2.使用 volatile关键字一定程度保证线程安全。使用原子类AutomicInteger保证线程安全。

    private static volatile Integer testIndex = 2000000;
    private static AtomicInteger atomicInteger = new AtomicInteger(1000000);

    public static void main(String[] args) {
        long l1 = System.currentTimeMillis();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                50,
                200,
                10L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>(10000));

        CompletableFuture.supplyAsync(() -> {
                    while (atomicInteger.get() > 0 && testIndex > 0) {
                        try {
                            TimeUnit.MILLISECONDS.sleep(0);
                            autoAdd();
//                            atomicClassTest();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    return testIndex;
                }
        ,threadPoolExecutor);
        CompletableFuture.supplyAsync(() -> {
                    while (atomicInteger.get() > 0 && testIndex > 0) {
                        try {
                            TimeUnit.MILLISECONDS.sleep(0);
                            autoAdd();
//                            atomicClassTest();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    return testIndex;
                }
                ,threadPoolExecutor);
        CompletableFuture.supplyAsync(() -> {
                    while (atomicInteger.get() > 0 && testIndex > 0) {
                        try {
                            TimeUnit.MILLISECONDS.sleep(0);
                            autoAdd();
//                            atomicClassTest();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    return testIndex;
                }
                ,threadPoolExecutor);
        CompletableFuture.supplyAsync(() -> {
                    while (atomicInteger.get() > 0 && testIndex > 0) {
                        try {
                            TimeUnit.MILLISECONDS.sleep(0);
                            autoAdd();
//                            atomicClassTest();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    return testIndex;
                }
                ,threadPoolExecutor);
        CompletableFuture.supplyAsync(() -> {
            while (atomicInteger.get() > 0 && testIndex > 0) {
                try {
                    TimeUnit.MILLISECONDS.sleep(0);
                        autoAdd();
//                    atomicClassTest();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return testIndex;
        }).thenRunAsync(() -> {
            System.out.println("耗时 " + (System.currentTimeMillis() - l1));
        });
        new Thread(() -> {
            for (; ; ) {
            }
        }).start();

    }

    public synchronized static void autoAdd() {
        --testIndex;
        System.out.println("线程操作了 " + testIndex);
    }

    public static void atomicClassTest() {
        System.out.println("原子类 " + atomicInteger.getAndAdd(-1));
    }
}

1.3.3.CAS详解：

1.3.3.1 ： CAS的全称为Compare-And-Swap（比较并提交） ,它是一条CPU并发原语,比较工作内存值(预期值)和主物理内存的共享值是否相同,相同则执行规定操作，否则继续比较直到主内存和工作内存的值一致为止。

CAS并发原语提现在Java语言中就是sun.misc包下的UnSaffe类中的各个方法.调用UnSafe类中的CAS方法,JVM会帮我实现 CAS汇编指令. 这是一种完全依赖于硬件功能,通过它实现了原子操作,由于CAS是一种系统原语,原语属于操作系统用于范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许中断,也即是说CAS是一条原子指令,不会造成所谓的数据不一致的问题。

其中 Unsafe 是CAS的核心类,由于Java 方法无法直接访问底层 ,需要通过本地(native)方法来访问,UnSafe相当于一个后门,基于该类可以直接操作特定的内存数据.UnSafe类在于sun.misc包中,其内部方法操作可以向C的指针一样直接操作内存,因为Java中CAS操作依赖于UnSafe类的方法

1.3.3.2 ： CAS缺陷。

1.阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

2.当对一个共享变量执行操作时,我们可以使用循环CAS的方式来保证原子操作

3.对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁来保证原子性

4. ABA问题的产生

一个线程one从内存位置V中取出A,这时候另一个线程two也从内存中取出A,并且线程two进行了一些操作将值变成了B,然后线程two又将V位置的数据变成A,这时候线程one进行CAS操作发现内存中仍然是A,然后线程one操作成功。尽管线程one的CAS操作成功,但是不代表这个过程就是没问题的

解决方案：

1. 使用 AtomicStampedReference 每修改一次都会有一个版本号。

2. AtomicStampedReference用来解决AtomicInteger中的ABA问题，该demo企图将integer的值从0一直增长到1000，但当integer的值增长到128后，将停止增长。出现该现象有两点原因：
使用int类型而非Integer保存当前值
Interger对-128~127的缓存[这个范围才有效,不在这个范围comareAndSet会一直返回false

1.4 ThreadLocal

ThreadLocal是什么？ThreadLocal即本地线程变量,线程自带的变量副本(实现了每一个线程副本都有一个专属的本地变量,主要解决的就是让每一个线程绑定自己的值,自己用自己的,不跟别人争抢。通过使用get()和set()方法,获取默认值或将其值更改为当前线程所存的副本的值从而避免了线程安全的问题)

对于ThreadLocal，几个要点：

        1. ThreadLocal本地线程变量,以空间换时间,线程自带的变量副本,人手一份,避免了线程安全问题
        2. 每个线程持有一个只属于自己的专属Map并维护了Thread Local对象与具体实例的映射,该Map由于只被持有它的线程访问,故不存在线程安全以及锁的问题
        3. ThreadLocalMap的Entry对ThreadLocal的引用为弱引用,避免了ThreadLocal对象无法被回收的问题
        4. 都会通过expungeStaleEntry,cleanSomeSlots, replace StaleEntry这三个方法回收键为 null 的 Entry 对象的值(即为具体实例)以及 Entry 对象本身从而防止内存泄漏,属于安全加固的方法
        5. 用完之后一定要remove操作

ThreadLocal的应用代码：使用ThreadLocal存储请求信息，例如当前用户用户名等，用于信息更新时的数据数据更改记录。例如：修改人等公共信息。

    private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();

    public static void setThreadLocal(String str) {
        THREAD_LOCAL.set(str);
    }

    public static String getThreadLocal() {
        return THREAD_LOCAL.get();
    }

    public static void removeThreadLocal() {
        THREAD_LOCAL.remove();
    }

    public static String getAndRemoveThreadLocal() {
        String local = THREAD_LOCAL.get();
        removeThreadLocal();
        return local;
    }

使用ThreadLocal控制 SqlSession的销毁创建工作，一定程度的提高了代码的可读性。

public class SqlSessionBaseContext {
    private static final ThreadLocal<SqlSession> SQL_SESSION_THREAD_LOCAL = new ThreadLocal<>();

    public static SqlSession getLocalSqlSession(){
        return SQL_SESSION_THREAD_LOCAL.get();
    }

    public static SqlSession getSqlSessionAndRemoveThreadLocal(){
        SqlSession sqlSession = SQL_SESSION_THREAD_LOCAL.get();
        SQL_SESSION_THREAD_LOCAL.remove();
        return sqlSession;
    }

    public static void setLocalSqlSession(SqlSession sqlSession){
        SQL_SESSION_THREAD_LOCAL.set(sqlSession);
    }

}

/**
 * Describe:用于操作SqlSession的封装
 *
 * @author OTM-CITRUS
 * @date 10/15/2022 3:09 PM
 */
public class SqlSessionUtils {
    /**
     * Describe:SqlSessionFactory
     */
    private static SqlSessionFactory SqlSessionFactory;

    private SqlSessionUtils() {
        //no instance
    }

    /*
     * Describe:初始化SqlSessionFactory，用于打开连接
     */
    static {
        try {
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * Describe:拿到连接方法
     *
     * @return org.apache.ibatis.session.SqlSession
     */
    public static SqlSession getSession() throws IOException {
        SqlSession sqlSession = SqlSessionFactory.openSession();
        SqlSessionBaseContext.setLocalSqlSession(sqlSession);
        return sqlSession;
    }

    /**
     * Describe:用于拿到是否自动提交的SqlSession的方法，用于事务处理
     *
     * @param transactional:
     * @return org.apache.ibatis.session.SqlSession
     */
    public static SqlSession getSession(Boolean transactional) throws IOException {
        SqlSession sqlSession = SqlSessionFactory.openSession(transactional);
        SqlSessionBaseContext.setLocalSqlSession(sqlSession);
        return sqlSession;
    }

    /**
     * Describe:用于提交事务的方法，通过ThreadLocal拿到已经存放的SqlSession，
     * 简化操作,提交后并且关闭Session连接，减少资源的无效占用
     */
    public static void commit() {
        SqlSession sqlSessionLocal = SqlSessionBaseContext.getSqlSessionAndRemoveThreadLocal();
        sqlSessionLocal.commit();
        sqlSessionLocal.close();
    }

    /**
     * Describe:用于回滚事务，在数据库操作发生异常时使用，回滚后并且会关闭连接
     */
    public static void rollback() {
        SqlSession sqlSessionLocal = SqlSessionBaseContext.getSqlSessionAndRemoveThreadLocal();
        sqlSessionLocal.rollback();
        sqlSessionLocal.close();
    }

}

1.5 线程中断Interrupt

1.一个线程不应该由其他线程来强制中断或停止,而是应该由线程自己自行停止,所以,Thread.stop、Thread.suspend、Thread. resume都已经被废弃了
2. 在Java中没有办法立即停止一条线程,然而停止线程却显得尤为重要,如取消一个耗时操作。因此,Java提供了一种用于停止线程的机制 — 中断
3. 中断只是一种协作机制,Java没有给中断增加任何语法,中断的过程完全需要程序员自己实现
4. 若要中断一个线程,你需要手动调用该线程的interrupt方法,该方法也仅仅是将线程对象的中断标识设为true
5. 每个线程对象中都有一个标识,用于标识线程是否被中断;该标识位为true表示中断,为false表示未中断;通过调用线程对象的interru pt方法将线程的标识位设为true;可以在别的线程中调用,也可以在自己的线程中调用。

public class InterruptDemo{
    static volatile boolean isStop = false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);

    public static void m3(){
    Thread t1 = new Thread(() -> {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("-----isInterrupted() = true,程序结束。");
                break;
            }
            System.out.println("------hello Interrupt");
        }
    }, "t1");
    t1.start();

    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

    new Thread(() -> {
        t1.interrupt();//修改t1线程的中断标志位为true
    },"t2").start();
}

    /**
     * 通过AtomicBoolean
     */
    public static void m2(){
        new Thread(() -> {
            while(true)
            {
                if(atomicBoolean.get())
                {
                    System.out.println("-----atomicBoolean.get() = true,程序结束。");
                    break;
                }
                System.out.println("------hello atomicBoolean");
            }
        },"t1").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            atomicBoolean.set(true);
        },"t2").start();
    }

    /**
     * 通过一个volatile变量实现
     */
    public static void m1(){
        new Thread(() -> {
            while(true)
            {
                if(isStop)
                {
                    System.out.println("-----isStop = true,程序结束。");
                    break;
                }
                System.out.println("------hello isStop");
            }
        },"t1").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            isStop = true;
        },"t2").start();
    }
}

1. 如果线程处于正常活动状态,那么会将线程的中断标志设置位true,仅此而已。被设置中断标志的线程将继续正常运行,不受影响。所以,interrupt( )并不能真正的中断线程,需要被调用的线程自己进行配合才行
2. 如果线程处于被阻塞状态(例如处于sleep、wait、join等状态),在别的线程中调用当前线程对象的interrupt方法,那么线程立即被阻塞状态,并抛出一个InterruptedException异常)
3.中断只是一种协同机制,修改中断标识位仅此而已,不是立即stop打断sleep方法抛出InterruptedException后,中断标识也被清空置为false,我们在catch没有通过调用th.interrupt( )方法再次将中断标识位设置位true,这就是导致无限循环了

 public static void m5()
    {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("-----isInterrupted() = true,程序结束。");
                    break;
                }
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    //线程的中断标志位重新设置为false,无法停下,需要再次掉interrupt()设置true
                    Thread.currentThread().interrupt();//???????
                    e.printStackTrace();
                }
                System.out.println("------hello Interrupt");
            }
        }, "t1");
        t1.start();

        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            t1.interrupt();//修改t1线程的中断标志位为true
        },"t2").start();
    }

    /**
     *中断为true后,并不是立刻stop程序
     */
    public static void m4()
    {
        //中断为true后,并不是立刻stop程序
        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= 300; i++) {
                System.out.println("------i: " + i);
            }
            System.out.println("t1.interrupt()调用之后02: "+Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();

        System.out.println("t1.interrupt()调用之前,t1线程的中断标识默认值: "+t1.isInterrupted());
        try { TimeUnit.MILLISECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        //实例方法interrupt()仅仅是设置线程的中断状态位设置为true,不会停止线程
        t1.interrupt();
        //活动状态,t1线程还在执行中
        System.out.println("t1.interrupt()调用之后01: "+t1.isInterrupted());

        try { TimeUnit.MILLISECONDS.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
        //非活动状态,t1线程不在执行中,已经结束执行了。
        System.out.println("t1.interrupt()调用之后03: "+t1.isInterrupted());
    }

2.多线程高级……

未完待续……

隔壁拓海老湿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java多线程学习2

1.基础篇。……上一篇地址：Java多线程学习1_隔壁拓海老湿的博客-CSDN博客java提供了丰富的多线程操作，直接使用Java.Lang.Concurrent包下的Api，即可开启使用Java提供的多线程功能。https://blog.csdn.net/SuzukiTakumiSama/article/details/128421450?spm=1001.2014.3001.55021.3.线程安全，锁，synchronized，ReentranLock，自旋锁，原子类，CAS。1.3
复制链接

扫一扫