精华内容
下载资源
问答
  • concurrent

    2014-11-03 09:54:20
    package com.oyd.concurrent.print; import java.util.Date;...import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Lock; import java.

     

    package com.oyd.concurrent.print;
    
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Print implements Runnable {
    	private static int i = 0;
    
    	private Lock lock = new ReentrantLock();
    
    	public static void main(String[] args) {
    		ExecutorService executorService = Executors.newFixedThreadPool(2);
    		Print print = new Print();
    		executorService.execute(print);
    		executorService.execute(print);
    		executorService.shutdown();
    	}
    
    	@Override
    	public void run() {
    		// if (lock.tryLock())
    		{
    			lock.lock();
    			try {
    				Thread.sleep(2000);
    				i++;
    				System.out.println(new Date() + "| i = " + i);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			} finally {
    				lock.unlock();
    			}
    		}
    	}
    }
    

     

    展开全文
  • concurrent

    2011-08-26 11:29:38
    package com.oyd.concurrent.print; import java.util.Date;...import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Lock; import ja...

     

    package com.oyd.concurrent.print;
    
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Print implements Runnable {
    	private static int i = 0;
    
    	private Lock lock = new ReentrantLock();
    
    	public static void main(String[] args) {
    		ExecutorService executorService = Executors.newFixedThreadPool(2);
    		Print print = new Print();
    		executorService.execute(print);
    		executorService.execute(print);
    		executorService.shutdown();
    	}
    
    	@Override
    	public void run() {
    		// if (lock.tryLock())
    		{
    			lock.lock();
    			try {
    				Thread.sleep(2000);
    				i++;
    				System.out.println(new Date() + "| i = " + i);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			} finally {
    				lock.unlock();
    			}
    		}
    	}
    }
    

     

    展开全文
  • import java.util.concurrent.TimeUnit; public class Semaphore implements java.io.Serializable { private static final long serialVersionUID = -3222578661600680210L; // 序列化版本号 private final Sync...

    源码先贴上,后面是实际使用的时候代码的执行流程

    import java.util.Collection;
    import java.util.concurrent.TimeUnit;
    
    public class Semaphore implements java.io.Serializable {
        private static final long serialVersionUID = -3222578661600680210L; // 序列化版本号
        private final Sync sync; // 抽象队列同步器的子类成员常量
    
    
        // 构造方法
        /**
         * 构造一个有permits个信号量的非公平同步器
         */
        public Semaphore(int permits) {
            sync = new NonfairSync(permits);
        }
    
        /**
         * 构造一个有permits个信号量
         * 如果传入的布尔值fair=true则是公平同步器,false则是非公平同步器
         */
        public Semaphore(int permits, boolean fair) {
            sync = fair ? new FairSync(permits) : new NonfairSync(permits);
        }
    
    
        /**
         * 下面是常用方法
         */
        /**
         * 获取信号量
         */
        // 获取一个信号量,如果信号量被使用完则抛异常InterruptedException
        public void acquire() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }
    
        // 获取permits个信号量,如果不够则抛异常InterruptedException
        public void acquire(int permits) throws InterruptedException {
            if (permits < 0) throw new IllegalArgumentException();
            sync.acquireSharedInterruptibly(permits);
        }
    
        // 获取permits个不可中断的信号量
        public void acquireUninterruptibly(int permits) {
            if (permits < 0) throw new IllegalArgumentException();
            sync.acquireShared(permits);
        }
    
        // 阻塞式(就是等待)获取信号量,当其它信号量被释放,并执行当前代码则成功
        public void acquireUninterruptibly() {
            sync.acquireShared(1);
        }
    
        /**
         * 释放信号量方法
         */
        // 释放一个信号量
        public void release() {
            sync.releaseShared(1);
        }
    
        // 释放permits个信号量
        public void release(int permits) {
            if (permits < 0) throw new IllegalArgumentException();
            sync.releaseShared(permits);
        }
    
        /**
         * 常用信号量辅助方法
         */
        // 获取所有信号量,并将所有信号量都使用掉,返回0
        public int drainPermits() {
            return sync.drainPermits();
        }
    
        // 获取可用的信号量个数
        public int availablePermits() {
            return sync.getPermits();
        }
    
        // 获取等待线程队列的长度
        public final int getQueueLength() {
            return sync.getQueueLength();
        }
    
        /**
         * 判断信号量方法
         */
        // 判断是否可以获取一个信号量
        public boolean tryAcquire() {
            return sync.nonfairTryAcquireShared(1) >= 0;
        }
        // 判断是否可以获取permits个信号量
        public boolean tryAcquire(int permits) {
            if (permits < 0) throw new IllegalArgumentException();
            return sync.nonfairTryAcquireShared(permits) >= 0;
        }
        // 判断在指定时间内可否获取一个信号量,超过等待时间timeout则抛异常InterruptedException
        public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {
            return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
        }
        // 判断在timeout时间内是否可以获取permits个信号量throws InterruptedException
        public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException {
            if (permits < 0) throw new IllegalArgumentException();
            return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
        }
        // 判断是否是公平机制的信号同步器
        public boolean isFair() {
            return sync instanceof FairSync;
        }
        // 判断线程队列是否有线程,有线程在等待获取信号量则返回true,否则返回false
        public final boolean hasQueuedThreads() {
            return sync.hasQueuedThreads();
        }
    
        /**
         * toString方法得到信号量
         */
        public String toString() {
            return super.toString() + "[Permits = " + sync.getPermits() + "]";
        }
    
    
        /**
         * 获取线程队列的集合
         */
        protected Collection<Thread> getQueuedThreads() {
            return sync.getQueuedThreads();
        }
        // 减少reduction个信号量(总量减少)
        protected void reducePermits(int reduction) {
            if (reduction < 0) throw new IllegalArgumentException();
            sync.reducePermits(reduction);
        }
    
        /**
         * 同步器的抽象方法
         */
        abstract static class Sync extends AbstractQueuedSynchronizer {
            private static final long serialVersionUID = 1192457210091910933L;  // 序列化版本号
    
            // 带一个参数的构造方法
            Sync(int permits) {
                setState(permits);// 调用AQS中的setState
            }
            // 获得许可数量
            final int getPermits() {
                return getState();//调用AQS的方法
            }
    
            // 使用acquires个信号量,失败则直接返回计算得到的剩余信号量的值
            final int nonfairTryAcquireShared(int acquires) {
                for (; ; ) {
                    int available = getState();//不断自旋获取当前剩余信号量
                    int remaining = available - acquires;//计算剩余信号量
                    //前面如果false则需要执行后面的cas操作更新信号量,如果剩余信号量大于0则将这个负值的信号量直接返回
                    if (remaining < 0 || compareAndSetState(available, remaining))
                        return remaining;
                }
            }
            // 释放releases个信号量 失败则会抛异常
            protected final boolean tryReleaseShared(int releases) {
                for (; ; ) {
                    int current = getState();// 不断自旋获取当前许可值
                    int next = current + releases;// 计算释放后的新许可值
                    if (next < current) // 超过了最大值(构造的时候传入的值)需要抛异常
                        throw new Error("Maximum permit count exceeded");
                    if (compareAndSetState(current, next))// 说明没有超过最大值,进行更新许可值,并返回true
                        return true;
                }
            }
    
            // 使用reductions个信号量减少的是总量,也就是最大值
            final void reducePermits(int reductions) {
                for (; ; ) {
                    int current = getState(); // 当前许可
                    int next = current - reductions;// 计算减少后的新的总量
                    if (next > current) // 新的总量不能比之前的总量大,大则抛异常
                        throw new Error("Permit count underflow");
                    if (compareAndSetState(current, next))
                        return;
                }
            }
    
            final int drainPermits() {
                for (; ; ) {
                    int current = getState();
                    if (current == 0 || compareAndSetState(current, 0)) // 将信号量更新为0,表示全部使用完了
                        return current;
                }
            }
        }
    
        /**
         * 实现同步器的公平同步器
         */
        static final class FairSync extends Sync {
            private static final long serialVersionUID = 2014338818796000944L;
    
            FairSync(int permits) {
                super(permits);
            }
    
            //尝试获取信号量(公平锁机制)
            protected int tryAcquireShared(int acquires) {
                for (; ; ) {
                    if (hasQueuedPredecessors()) //如果已经形成了AQS队列,说明信号量早用完了,直接返回-1
                        return -1;
                    int available = getState();  //当前可用信号量
                    int remaining = available - acquires;// 计算使用了acquires信号量的值
                    if (remaining < 0 || compareAndSetState(available, remaining))// 值小于0直接返回计算后的负值remaining,不小于0则说明不会进行阻塞
                        return remaining;
                }
            }
        }
    
        /**
         * 实现同步器的非公平同步器
         */
        static final class NonfairSync extends Sync {
            private static final long serialVersionUID = -2694183684443567898L;
    
            NonfairSync(int permits) {
                super(permits);
            }
    
            //尝试获取信号量(非公平锁机制)
            protected int tryAcquireShared(int acquires) {
                return nonfairTryAcquireShared(acquires); // 调用父类Sync种的final方法
            }
        }
    
    }
    

    探究Semaphore 的使用以及流程搞定原理

    此前你需要掌握AQS原理,以及CAS
    AQS原理和CAS相关文章点这里

    在我们使用的时候使用new Semaphore (信号量初始值)得到一个信号量的实例对象。
    当我们调用acquire()或者acquire(int permits)使用信号量时,我们看下前面源码,实际上使用的时非公平锁的实例对象,也就是NonfairSync的实例。
    看下使用信号量会执行哪些代码,我们已空参的acquire()为例。

    // 获取一个信号量,如果信号量被使用完则抛异常InterruptedException
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    

    会发现调用的则是AQS的final方法,传入的arg=1

    public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
        if (Thread.interrupted() 
        		|| (tryAcquireShared(arg) < 0 
        		&& acquire(null, arg, true, true, false, 0L) < 0))
            throw new InterruptedException();
    }
    

    在这个方法中会发现会执行tryAcquireShared(1)这个方法则在子类中实现,需要返回到Semaphore的NonfairSync类中定义的该方法如下:

    //尝试获取信号量(非公平锁机制)
    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires); // 调用父类Sync种的final方法
    }
    

    会发现这个nonfairTryAcquireShared(1)又是NonfairSync的父类Sync中定义的

    // 使用acquires个信号量,失败则直接返回计算得到的剩余信号量的值
    final int nonfairTryAcquireShared(int acquires) {
        for (; ; ) {
            int available = getState();//不断自旋获取当前剩余信号量
            int remaining = available - acquires;//计算剩余信号量
            //前面如果false则需要执行后面的cas操作更新信号量,如果剩余信号量大于0则将这个负值的信号量直接返回
            if (remaining < 0 || compareAndSetState(available, remaining))
                return remaining;
        }
    }
    

    也就是返回使用了1个信号量剩余的信号量值,如果使用后信号量剩余>=0则使用成功,对信号量进行更新,小于0则直接将计算结果后的值直接返回(结果为负值的情况),>=0也会返回,但是会进行更新信号量操作。

    这里会发现里面有一个getState()方法来自于AQS,也就是在我们实例Semaphore时会按照如下顺序将state值赋值为我们传入Semaphore的值,也就是信号量。

    注意构造的时候是逆序构造的,需要先构造好父类才可以子类,这里面只是将这个信号量的初始值一直传到了AQS并赋值给了state

    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
    
    NonfairSync(int permits) {
        super(permits);
    }
    
    // 带一个参数的构造方法
    Sync(int permits) {
        setState(permits);// 调用AQS中的setState
    }
    
    protected AbstractQueuedSynchronizer() {
    }
    

    回到代码,看我加的注释

    public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
        if (Thread.interrupted() 
        		|| (tryAcquireShared(arg) < 0  //这里如果返回的剩余信号量<0也就是true,
         // 意味着需要阻塞线程,也就是判断中后面一个判断acquire方法会执行,如果不小于0则说明信号量没有被过度消费
        		&& acquire(null, arg, true, true, false, 0L) < 0))
            throw new InterruptedException();
    }
    

    acquire()我们在AQS就读过一遍,我们接着看下Semaphore的acquire流程

    通过源码我们很容易发现原来和ReentrantLock差不多就是走的分支不同,但是最终同样和ReetrantLock形成的队列差不多
    换而言之,Semaphore如果信号量设置为1,可以相当于低配版的ReentrantLock。
    为了更方便的读源码,我们借助工具Idea进行调试,不然acquire中定义的变量、以及分支够你看的眼花。

    public class SyncTest {
    
        public static void main(String[] args) {
            Semaphore semaphore=new Semaphore(1);
            for (int i = 0; i < 2; i++) {
                    try {
                        semaphore.acquire();//此处加断点,在第二次循环时进入这个方法,会一直到AQS的acquire方法最终会被阻塞因为信号量被使用完了
    					// semaphore.release(); //释放信号量调用这个
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }
        }
    }
    

    根据我加的注释在semaphore.acquire();加断得,我们重点看第二次循环,看下Semaphore类的AQS队列是怎么形成的。
    前面变量定义省略,直接看进入自旋
    第一层的if判断不会进入
    在这里插入图片描述
    看下面的if发现这里会进入,我们继续追踪
    在这里插入图片描述
    在这里插入图片描述
    这个方法有子类非公平同步器实现
    在这里插入图片描述
    又间接调用父类Sync的方法,这个方法就是计算剩余信号量,和前面差不多逻辑返回计算后剩余的信号量
    根据我在Semaphore源码中的注释继续执行

    在这里插入图片描述
    在这里插入图片描述
    也就意味着不执行if(acquired)内代码块
    然后和ReentrantLock一样创建了一样的头节点
    在这里插入图片描述
    后面的逻辑和ReentrantLock一致,唯一区别在于Semaphore走的分支不同。
    最终也会执行acquire方法中LockSupport.park()阻塞线程
    如下:
    在这里插入图片描述

    释放信号量,应该和ReentrantLock差不多,如果释放了信号量信号量>=1则会尝试从AQS队列中将对应线程唤醒

    展开全文
  • 这个工程是为了学习guava concurrent中的AbstractFuture而建立的,里面有可以运行的例子,再配合我的博客:https://blog.csdn.net/o1101574955/article/details/82889851,可以看明白guava concurrent的基本设计思路...
  • concurrent 杂记

    2015-09-02 17:09:26
    concurrent 杂记
  • ConcurrentMap

    万次阅读 2019-05-13 11:40:14
    ConcurrentMap,它是一个接口,是一个能够支持并发访问的java.util.map集合; ConcurrentHashMap是一个线程安全,并且是一个高效的HashMap。 spring缓存注解通过查看源代码发现将数据存在ConcurrentMap中 1 Map...

    ConcurrentMap,它是一个接口,是一个能够支持并发访问的java.util.map集合;

    ConcurrentHashMap是一个线程安全,并且是一个高效的HashMap。

    spring 缓存注解 通过查看源代码发现将数据存在ConcurrentMap中

    1 Map并发集合

    1.1 ConcurrentMap

    ConcurrentMap,它是一个接口,是一个能够支持并发访问的java.util.map集合;

    在原有java.util.map接口基础上又新提供了4种方法,进一步扩展了原有Map的功能:

    public interface ConcurrentMap<K, V> extends Map<K, V> {
    
        //插入元素
        V putIfAbsent(K key, V value);
    
        //移除元素
        boolean remove(Object key, Object value);
    
        //替换元素
        boolean replace(K key, V oldValue, V newValue);
    
        //替换元素
        V replace(K key, V value);
    }
    

    putIfAbsent:与原有put方法不同的是,putIfAbsent方法中如果插入的key相同,则不替换原有的value值;

    remove:与原有remove方法不同的是,新remove方法中增加了对value的判断,如果要删除的key--value不能与Map中原有的key--value对应上,则不会删除该元素;

    replace(K,V,V):增加了对value值的判断,如果key--oldValue能与Map中原有的key--value对应上,才进行替换操作;

    replace(K,V):与上面的replace不同的是,此replace不会对Map中原有的key--value进行比较,如果key存在则直接替换;

    其实,对于ConcurrentMap来说,我们更关注Map本身的操作,在并发情况下是如何实现数据安全的。在java.util.concurrent包中,ConcurrentMap的实现类主要以ConcurrentHashMap为主。接下来,我们具体来看下。

    1.2 ConcurrentHashMap

    ConcurrentHashMap是一个线程安全,并且是一个高效的HashMap。

    但是,如果从线程安全的角度来说,HashTable已经是一个线程安全的HashMap,那推出ConcurrentHashMap的意义又是什么呢?

    说起ConcurrentHashMap,就不得不先提及下HashMap在线程不安全的表现,以及HashTable的效率!

    • HashMap

    关于HashMap的讲解,在此前的文章中已经说过了,本篇不在做过多的描述,有兴趣的朋友可以来这里看下--HashMap

    在此节中,我们主要来说下,在多线程情况下HashMap的表现?

    HashMap中添加元素的源码:(基于JDK1.7.0_45)

    public V put(K key, V value) {
        。。。忽略
        addEntry(hash, key, value, i);
        return null;
    }
    void addEntry(int hash, K key, V value, int bucketIndex) {
        。。。忽略
        createEntry(hash, key, value, bucketIndex);
    }
    //向链表头部插入元素:在数组的某一个角标下形成链表结构;
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
    

    在多线程情况下,同时A、B两个线程走到createEntry()方法中,并且这两个线程中插入的元素hash值相同,bucketIndex值也相同,那么无论A线程先执行,还是B线程先被执行,最终都会2个元素先后向链表的头部插入,导致互相覆盖,致使其中1个线程中的数据丢失。这样就造成了HashMap的线程不安全,数据的不一致;

    更要命的是,HashMap在多线程情况下还会出现死循环的可能,造成CPU占用率升高,导致系统卡死。

    举个简单的例子:

    public class ConcurrentHashMapTest {
        public static void main(String[] agrs) throws InterruptedException {
    
            final HashMap<String,String> map = new HashMap<String,String>();
    
            Thread t = new Thread(new Runnable(){
                public  void run(){
                    
                    for(int x=0;x<10000;x++){
                        Thread tt = new Thread(new Runnable(){
                            public void run(){
                                map.put(UUID.randomUUID().toString(),"");
                            }
                        });
                        tt.start();
                        System.out.println(tt.getName());
                    }
                }
            });
            t.start();
            t.join();
        }
    }
    

    在上面的例子中,我们利用for循环,启动了10000个线程,每个线程都向共享变量中添加一个元素。

    测试结果:通过使用JDK自带的jconsole工具,可以看到HashMap内部形成了死循环,并且主要集中在两处代码上。

    image

     

    image

    那么,是什么原因造成了死循环?

    HashMap--put()494行:(基于JDK1.7.0_45)

    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {------**for循环494行**
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }
    

    HashMap--transfer()601行:(基于JDK1.7.0_45)

    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }-----**while循环601行**
        }
    }
    

    通过查看代码,可以看出,死循环的产生:主要因为在遍历数组角标下的链表时,没有了为null的元素,单向链表变成了循环链表,头尾相连了。

    以上两点,就是HashMap在多线程情况下的表现。

    • HashTable

    说完了HashMap的线程不安全,接下来说下HashTable的效率!!

    HashTable与HashMap的结构一致,都是哈希表实现。

    与HashMap不同的是,在HashTable中,所有的方法都加上了synchronized锁,用锁来实现线程的安全性。由于synchronized锁加在了HashTable的每一个方法上,所以这个锁就是HashTable本身--this。那么,可想而知HashTable的效率是如何,安全是保证了,但是效率却损失了。

    无论执行哪个方法,整个哈希表都会被锁住,只有其中一个线程执行完毕,释放所,下一个线程才会执行。无论你是调用get方法,还是put方法皆是如此;

    HashTable部分源码:(基于JDK1.7.0_45)

    public class Hashtable<K,V> extends Dictionary<K,V> 
        implements Map<K,V>, Cloneable, java.io.Serializable {
        
        public synchronized int size() {...}
    
        public synchronized boolean isEmpty() {...}
    
        public synchronized V get(Object key) {...}
    
        public synchronized V put(K key, V value) {...}
    }
    

    通过上述代码,可以清晰看出,在HashTable中的主要操作方法上都加了synchronized锁以来保证线程安全。

    说完了HashMap和HashTable,下面我们就重点介绍下ConcurrentHashMap,看看ConcurrentHashMap是如何来解决上述的两个问题的!

    1.3 ConcurrentHashMap结构

    在说到ConcurrentHashMap源码之前,我们首先来了解下ConcurrentHashMap的整体结构,这样有利于我们快速理解源码。

    不知道,大家还是否记得HashMap的整体结构呢?如果忘记的话,我们就在此进行回顾下!

    image

    HashMap底层使用数组和链表,实现哈希表结构。插入的元素通过散列的形式分布到数组的各个角标下;当有重复的散列值时,便将新增的元素插入在链表头部,使其形成链表结构,依次向后排列。

    下面是,ConcurrentHashMap的结构:

    image

    与HashMap不同的是,ConcurrentHashMap中多了一层数组结构,由Segment和HashEntry两个数组组成。其中Segment起到了加锁同步的作用,而HashEntry则起到了存储K.V键值对的作用。

    在ConcurrentHashMap中,每一个ConcurrentHashMap都包含了一个Segment数组,在Segment数组中每一个Segment对象则又包含了一个HashEntry数组,而在HashEntry数组中,每一个HashEntry对象保存K-V数据的同时又形成了链表结构,此时与HashMap结构相同。

    在多线程中,每一个Segment对象守护了一个HashEntry数组,当对ConcurrentHashMap中的元素修改时,在获取到对应的Segment数组角标后,都会对此Segment对象加锁,之后再去操作后面的HashEntry元素,这样每一个Segment对象下,都形成了一个小小的HashMap,在保证数据安全性的同时,又提高了同步的效率。只要不是操作同一个Segment对象的话,就不会出现线程等待的问题!




    链接:https://www.jianshu.com/p/8f7b2cd34c47
     

    展开全文
  • 简化 java.util.concurrent.CopyOnWriteArrayList 源码并总结知识点 会发现CopyOnWriteArraySet会比CopyOnWriteArrayList代码量少一些,因为本质就是给CopyOnWriteArrayList套了一层壳。 这里我们需要思考的问题是...
  • concurrentmap-源码

    2021-04-10 19:18:51
    concurrentMap := concurrentmap . New ( concurrentmap . WithBucket ( 32 )) concurrentMap . Store ( "1" , 1 ) if v , ok := concurrentMap . Load ( "1" ); ok { fmt . Printf ( " v = %v \n " , v ) ...
  • concurrent集合

    2018-09-07 17:54:30
    转载请注明链接: concurrent集合 版本号:2018/9/7-1(18:18) concurrent集合 ConcurrentHashMap CopyOnWriteArrayList ConcurrentHashMap CopyOnWriteArrayList
  • Concurrent Programming in Java Concurrent Programming in Java
  • This course teaches learners (industry professionals and students) the fundamental concepts of concurrent programming in the context of Java 8. Concurrent programming enables developers to efficient.....
  • Concurrent.Thread

    2018-12-18 18:43:02
    Concurrent.Thread.js插件从20071219到20090713各个版本都有,简单做了打包,资源分数不能设置为0,大家可以到我的百度云盘分享链接下载 https://pan.baidu.com/s/1iD0DbIkUDWQ9OZHMP4hsig 提取码:xsy4
  • java.util.concurrent

    2017-05-12 17:42:55
    concurrent
  • package ...import java.util.concurrent.*;import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public c...
  • concurrent

    2017-10-06 20:11:57
    通常所说的concurrent包基本有3个package组成 java.util.concurrent:提供大部分关于并发的接口和类,如BlockingQueue,Callable,ConcurrentHashMap,ExecutorService, Semaphore等 java.util.concurrent.atomic:...
  • Windows及其他平台并发编程知识Concurrent Programming on Windows
  • Practical Concurrent Haskell.pdf Practical Concurrent Haskell.pdf Practical Concurrent Haskell.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,866
精华内容 32,346
关键字:

concurrent