多线程（并发）学习笔记

最新推荐文章于 2023-09-15 15:01:57 发布

zdw890412

最新推荐文章于 2023-09-15 15:01:57 发布

阅读量1.5k

点赞数

分类专栏： java 文章标签：多线程 object 数据结构 exception 算法 class

本文链接：https://blog.csdn.net/zdw890412/article/details/7692255

版权

java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

1，无论以哪种方式启动一个线程，要给线程一个名字，对排错、监控有帮助。

2，要对线程interrupt做处理。

3，Futrure 是任务的提交者和执行者之间的通讯手段，get（）会阻塞；

  ExecutorService executor = Executors.newSingleThreadExecutor();
    Callable<Object> task = new Callable<Object>() {
        
        @Override
        public Object call() throws Exception {

            Object result= "...";
            return result;
        }
    };
    
    Future<Object> future =executor.submit(task);
    future.get();

4，阻塞队列，常用的数据结构，用于生产者消费者模式，常用三种阻塞队列为ArrayBlockingQueue,LinkedBlockingQueue,SynchronousQueue,

使用阻塞队列时不要使用从Queue继承下来的方法，否则失去Blocking特性。

在BlockingQueue中那个，使用put和take，而非offer和poll。

下面是用lock实现blockingq的pv操作

public class BlockingQ {
    private Lock lock = new ReentrantLock();
    private Condition notEmpty = lock.newCondition();
    private Condition notFull = lock.newCondition();
    private Queue<Object> linkedList = new LinkedList<Object>();
    private int maxLenght = 10;
    
    public Object take() throws InterruptedException{
        lock.lock();
        try{
            if(linkedList.size() == 0){
                notEmpty.await();
            }
            if(linkedList.size() == maxLenght){
                notFull.signalAll();
            }
            return linkedList.poll();
        }finally{
            lock.unlock();
        }   
    }
    
    public void offer(Object object) throws InterruptedException{
        lock.lock();
        try{
            if(linkedList.size() == 0){
                notEmpty.signalAll();
                
            }
            
            if(linkedList.size() == maxLenght){
                notFull.await();
            }
            linkedList.add(object);
        }finally{
            lock.unlock();
        }
    }
    
    
    
}

5，ReentrantLock和Synchronized的关系

Synchronized是lock的一种简化实现，一个lock可以对应多个Condition，而Syschronized把lock和Condition合并了，可以说Syschronized是Lock简易版本，而且效率没有lock高。

6，代替锁得办法，硬件原子操作，lockfree算法。lockfree算法分三个步骤，循环，CAS（compare and set），返回。

7，concurrentHashMap数据结构使用了lockfree的算法，支持多个writer并发。

未完待续。。。。