码迷,mamicode.com
首页 > 编程语言 > 详细

多线程杂记

时间:2020-03-28 10:39:05      阅读:81      评论:0      收藏:0      [点我收藏+]

标签:模式   inter   slot   规则   rgs   结合   释放   出现   actor   

阻塞线程关键字
java内存模型
单利模式
threadLocal

阻塞线程关键字

线程有几种状态?
新建状态、就绪状态、运行状态、阻塞状态、死亡状态

使线程进入阻塞状态的几种方式?
wait、yield、sleep、join、interrupt

wait
使当前线程让出锁,进入阻塞状态,直到超时或者notify,线程进入就绪状态

public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    Thread.sleep(1000);
                    System.out.println("2");
                    synchronized (this){
                        notify();
                    }
                    System.out.println("3");
                }catch (Exception e){
                }
            }
        });
        t1.start();
        synchronized (t1){
            try{
                System.out.println("5");
                t1.wait();
                System.out.println("4");
            }catch (Exception e){
            }
        }

    }

关于wait有两点要注意
1、wait和notify必须要sychronize代码块中
2、wait阻塞的不是调用它的那个线程,而是当前线程。如上代码,t1.wait(),阻塞的是当面线程(也就是main方法的线程),而t1这个线程继续运行。

yield
让线程进入就绪状态,但是不会释放锁。

sleep
让现场进入阻塞状态,到时间后进入就绪状态,不释放锁。

join
阻塞父线程,等待子线程执行完毕,底层用wait方法实现

 public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    Thread.sleep(1000);
                    System.out.println("3");
                }catch (Exception e){
                }
            }
        });
        t1.start();
        try{
            t1.join();//主线程是父线程、t1是子线程
            System.out.println("123");
        }catch (Exception e){
        }
    }

interrupt
给线程一个中断标识,不会中断线程,需要自己根据中断标识去中断线程

public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    while (!Thread.currentThread().isInterrupted()){
                        System.out.println("xx");
                    }
                }catch (Exception e){
                }
            }
        });
        t1.start();
        try{
            Thread.sleep(3000);
            t1.interrupt();
        }catch (Exception e){
        }
    }

返回顶部

java内存模型

内存模型(jmm)是java定义的一些规则,目的是为了解决并发安全问题。
线程工作的时候会有把变量重主内存load到工作内存中去操作,然后在回写到主内存,这个过程如果发生在多线程下就会存在安全问题。jmm就是解决这个问题的。

jmm定义了三个原则:有序性、可见行、原子性。只要代码能保证这三个原则,就能避免并发安全问题。

jmm8个基本原子动作,lock unlock read load use assgin store write
但是long和double类型的这9个基本动作不能保证原子性,也就是对long和double类型的read和load操作中间可能被其他线程插入。

这三个原则分别是什么?jmm如何保证这三个原则?
原子性:当线程要修改一个变量i的值时,分三步
1、将i load到工作内存
2、修改工作内存中i的值
3、回写i的值到主内存中
这个过程并不是原子的,也就是当i回写到主内存时其他线程可能已经修改过i的值了。

可见性:还是上边那个例子,在当前线程在使用i的过程中,其他线程修改了i的值,如果能当前线程可以立马知道,就是可见性。

有序性:比如有如下代码:
int i=0;
int j=0;
int i=j+1;
理论上java应该是按照顺序执行这三行代码,但是并不是,jvm为了优化性能,会打乱顺序来执行这三行代码,这就算有序性。

那么如何保证这三个原则?
1、锁。
2、jmm制定了一些天然的规则(happen-before原子)可以保证这三个原则。
3、concurrent包下的automic系列关键字、cas、volitle关键字。

happen-before原则:比如A代码在B代码之前,那么当执行B代码的时候,A代码产生的且对B有影响的改变,B都是可以感知到的。
具体有8个原则:
1、程序次序规则:单线程程序按照代码顺序执行,单线程环境,不需要过多考虑。
2、管程锁定规则:对于同一个锁,unlock肯定先行发生与lock,其实就是多线程竞争锁

public class XxxTest {

    public static void main(String[] args) {
        XxxTest a = new XxxTest();
       Thread t1 = new Thread(new Runnable() {
           @Override
           public  void run() {
               synchronized(a){//线程t1获取对象a的锁
                   try{
                       new Thread().sleep(2000);
                       System.out.println("22");
                   }catch (Exception e){
                   }
               }

           }
       });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public  void run() {
                synchronized(a) {//线程t1 unlock之前,此处t2的lock会等待
                    System.out.println("123");
                }
            }
        });
            t1.start();
            t2.start();
    }
}

3、volatile变量规则:对一个变量的写操作先行发生与读操作。
个人理解这个就是指volatile可见性。


public class XxxTest {

    static volatile boolean flag = false;

    public static void main(String[] args) {
       Thread t1 = new Thread(new Runnable() {
           @Override
           public  void run() {
               try{
                   while (!flag){//一旦线程t2更新flag,这里马上可见

                   }
                   System.out.println("线程t1读取到了线程t2更新到主内存的值");
               }catch (Exception e){
               }

           }
       });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public  void run() {
                flag  = true;//线程t2更新flag后马上刷新主内存
            }
        });
            t1.start();
            try{
                new Thread().sleep(2000);//这里保证先进入线程t1
                t2.start();
            }catch (Exception e){
            }

    }
}

4、传递规则:A发生B之前,B发生在C之前,那么A一定发生在C之前。
5、线程启动规则:Thread对象的start方法先行发生于此对象的每一个操作。
6、线程终止规则:线程的所有操作都先行发生与对此线程的终止检测
7、线程中断规则:
8、对象终结规则:一个对象的初始化(构造函数)的执行先行发生于他的finalize方法

返回顶部

单利模式

1、最初级写法:

public class Singleton {
    private static Singleton self;
    private Singleton(){}
    public static Singleton getInstance(){
        if(self==null){
            //并发环境,多个线程可能同时进到这里
            return new Singleton();
        }
        return self;
    }
}

但是多线程的情况下就不是单利了,改进加锁:
2、

public class Singleton {
    private static Singleton self;
    private Singleton(){}
    public synchronized static Singleton getInstance(){//此处加锁解决并发安全,但是锁整个方法效率低
        if(self==null){
            return new Singleton();
        }
        return self;
    }
}

锁整个方法效率低,在次优化,锁方法改成锁代码块:

public class Singleton {
    private static Singleton self;
    private Singleton(){}
    public static Singleton getInstance(){
        if(self==null){
            //并发下A、B两个线程可以同时到这里,A获取锁执行下边代码,B卡在这里等待
            //当A执行完释放锁后,B又可以获取锁再次new出个对象
            synchronized(Singleton.class){
                return new Singleton();
            }
        }
        return self;
    }
}

还存在并发问题,继续优化:

public class Singleton {
    private static Singleton self;
    private Singleton(){}
    public static Singleton getInstance(){
        if(self==null){
            //并发下A、B两个线程可以同时到这里,A获取锁执行下边代码,B卡在这里等待
            //当A执行完释放锁后,B又可以获取锁再次new出个对象
            synchronized(Singleton.class){
                //B线程进来的时候再次判断一下
                if(self!=null){
                    return new Singleton();
                }
            }
        }
        return self;
    }
}

但是此时还存在一个指令重排的问题,new Singleton()这端代码在内存中包括三个步骤:
1、分配内存空间
2、初始化对象
3、赋值给变量
这三个步骤存在指令重排的情况,可能先执行3,后执行2,当3执行完了,其他线程就可能已经获取到该对象了,但是2还未执行,使用该对象时就会出现问题。
新的内存模型可以使用volitatle关键字禁止指令重排,如上代码把Singleton变量用volitatle修饰就可以解决,但是volitatle性能低。所以又出现了终极方案,内部类。

public class Singleton {
    private Singleton(){}
    private static class SingletonFactory{
        public static final Singleton self = new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonFactory.self;
    }
}

返回顶部

threadLocal

多线程访问threadLocal类型的变量时,每个线程的变量数据会单独存储,互相隔离。

public static void main(String[] args) {
        ThreadLocal threadLocal = new ThreadLocal();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set("t1");
                System.out.println("线程t1:"+threadLocal.get());
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set("t2");
                System.out.println("线程t2:"+threadLocal.get());
            }
        });
        t1.start();
        t2.start();
    }

内部实现

1、每个Thread持有一个ThreadLocalMap
技术图片
2、ThreadLocalMap是ThreadLocal内部类,内部维护一个Entry数组,定义几个ThreadLocal变量,Entry数组就有几个值。结合下面代码更好理解:

public static void main(String[] args) {
       //后续管它叫ThreadLocal变量 
        ThreadLocal threadLocal1 = new ThreadLocal();
        ThreadLocal threadLocal2 = new ThreadLocal();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //向线程t1的ThreadLocalMap添加两个元素,
                // 相当于在entry[0]位置添加值"value1",在entry[1]位置添加值"value2"
                threadLocal1.set("value1");
                threadLocal2.set("value2");
                System.out.println(threadLocal1.get());
                System.out.println(threadLocal2.get());
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //向线程t2的ThreadLocalMap添加一个元素
                threadLocal1.set("value2");
                System.out.println("线程t2:"+threadLocal1.get());
            }
        });
        //两个线程,t1、t2 相当于创建两个ThreadLocalMap,每个ThreadLocalMap是完全独立的
        t1.start();
        t2.start();
    }
 static class ThreadLocalMap {

        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            //k是当前ThreadLocal变量
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        //table初始大小
        private static final int INITIAL_CAPACITY = 16;
        //用来存放ThreadLocal变量
        private ThreadLocal.ThreadLocalMap.Entry[] table;
        private int size = 0;
    }

set方法:

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocal.ThreadLocalMap map = getMap(t);//获取当前线程的ThreadLocalMap
        if (map != null)
            map.set(this, value);
        else//如果是第一次添加,初始化ThreadLocalMap
            createMap(t, value);
    }
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
    }
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //初始化entry数组,大小为16
        table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
        //根据ThreadLocal变量作为key进行哈希 + entry数组大小,计算出当前ThreadLocal存放到数组的索引位置
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        //存入数组
        table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
        size = 1;
        setThreshold(INITIAL_CAPACITY);
    }
    private void set(ThreadLocal<?> key, Object value) {

         //先计算出要存入entry数组的索引位置,更新该位置的值
        ThreadLocal.ThreadLocalMap.Entry[] tab = table;
        int len = tab.length;
        int i = key.threadLocalHashCode & (len-1);

        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {//循环实际只走一遍
            ThreadLocal<?> k = e.get();

            if (k == key) {
                e.value = value;
                return;
            }

            if (k == null) {
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        //rehash进行扩容
        tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);
        int sz = ++size;
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }

get方法:

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map =t.threadLocals;//先获取该线程的ThreadLocalMap
        if (map != null) {
            //通过哈希+entry数组大小计算索引位置,直接索引数组即可
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //该方法会初始化一个ThreadLocalMap,同时返回的value为null
        return setInitialValue();
    }

    private Entry getEntry(ThreadLocal<?> key) {
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        if (e != null && e.get() == key)
            return e;
        else
            return getEntryAfterMiss(key, i, e);
    }

返回顶部

多线程杂记

标签:模式   inter   slot   规则   rgs   结合   释放   出现   actor   

原文地址:https://www.cnblogs.com/yanhui007/p/12585918.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!