JUC并发，Java多线程实现方式及并发与同步

    } finally {

        //释放锁

        lock.unlock();

    }

}

}

synchronized和lock区别：



1.  synchronize内置的java关键字，lock是一个java类

2.  synchronize无法获取锁的状态，lock可以判断是否获取到了锁

3.  前者会自动释放锁，lock必须手动释放锁，如果不释放锁，会造成死锁

4.  前者线程1（获得锁，阻塞）线程2（等待，一直等）；lock就不一定会等待下去。lock.tryLock();

5.  前者可重入锁，不可以中断，非公平；lock，可重入锁，可以判断锁，非公平（可以自己设置）；

6.  前者锁少量的代码同步问题，lock适合锁大量的同步代码！



锁是什么？如何判断锁的是谁？



new this 具体的一个手机



static Class 唯一的一个模板



4.生产者，消费者问题



6、集合类不安全

package com.it;

import java.util.*;

import java.util.concurrent.CopyOnWriteArrayList;

// java.util.ConcurrentModificationException

public class Test {

public static void main(String[] args) {

    //并发下ArrayList不安全

    /*

    * 解决方案：

    *   1.List<String> list = new Vector<>();

    *   2. List<String> list = Collections.synchronizedList(new ArrayList<>());

    *   3.List<String> list = new CopyOnWriteArrayList<>();

    * CopyOnWrite写入时复制，  COW  计算机程序设计领域的一种优化策略；

    * 多个线程调用的时候，list，读取的时候固定的，写入时（覆盖）

    * 在写入的时候避免覆盖，造成数据问题*/

    List<String> list = new CopyOnWriteArrayList<>();

    //List<String> list = new Vector<>();

    for (int i = 0; i < 10; i++) {

        new Thread(()->{

            list.add(UUID.randomUUID().toString().substring(0,5));

            System.out.println(list);

        },String.valueOf(i)).start();

    }

}

}

7、Callable



与Runbale区别：



1.  可以有返回值

    

2.  可以抛出异常

    

3.  方法不同，run（）/call()

    

    package com.it.test;

    

    import java.util.concurrent.Callable;  

    import java.util.concurrent.ExecutionException;  

    import java.util.concurrent.FutureTask;

    

    public class CallableTest {  

    public static void main(String\[\] args) throws ExecutionException, InterruptedException {  

    MyThread myThread = new MyThread();  

    //适配类  

    FutureTask futureTask = new FutureTask<>(myThread);  

    new Thread(futureTask,“A”).start();  

    new Thread(futureTask,“B”).start();//结果会被缓存  

    Integer o = (Integer) futureTask.get();//这个get可能会产生阻塞  

    System.out.println("o = " + o);

    

    ```

     } 

    ```

    

    }  

    class MyThread implements Callable{

    

    ```

     @Override

     public Integer call() throws Exception {

         System.out.println("call()");//会打印几个call

         //耗时的操作

         return 1024;

     } 

    ```

    

    }

    



 



  



本文转自 [https://blog.csdn.net/zab\_00/article/details/119052711](
)，如有侵权，请联系删除。