马克社区,马克吐温社区,马克java社区理论：第八章：线程是什么，有几种实现方式，它们之间的区别是什么，线程池实现原理，JUC并发包，ThreadLocal与Lock和Synchronize区别

理论：第八章：线程是什么，有几种实现方式，它们之间的区别是什么，线程池实现原理，JUC并发包，ThreadLocal与Lock和Synchronize区别

什么是线程？讲个故事给你听，让你没法去背这个题，地址：https://blog.csdn.net/java_wxid/article/details/94131223

有几种实现方式？

    继承Thread类
    实现Runnable接口
    实现Callable接口
    线程池方式

优缺点

1.继承Thread类

    优点、代码简单。
    缺点、该类无法集成别的类。

2.实现Runnable接口

    优点、继承其他类。同一实现该接口的实例可以共享资源。
    缺点、代码复杂

3.实现Callable

    优点、可以获得异步任务的返回值

4.线程池、实现自动化装配，易于管理，循环利用资源。

代码实现案例：

    继承Thread类，并重写里面的run方法
    class A extends Thread{
        public void run(){
            for(int i=1;i<=100;i++){
                System.out.println("-----------------"+i);
            }
        }
    }
    A a = new A();
    a.start();

    实现Runnable接口，并实现里面的run方法
    class B implements Runnable{
        public void run(){
            for(int i=1;i<=100;i++){
                System.out.println("-----------------"+i);
            }
        }
    }
    B b = new B();
    Thread t = new Thread(b);
    t.start();
    实现Callable
    class A implements Callable<String>{
        public String call() throws Exception{
            //...
        }
    }
    FutureTask<String> ft = new FutureTask<>(new A());
    new Thread(ft).start();
    线程池
    ExcutorService es = Executors.newFixedThreadPool(10);
    es.submit(new Runnable(){//任务});
    es.submit(new Runnable(){//任务});
    ...
    es.shutdown();

问题扩展

在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？

整体上来说Lock是synchronized的扩展版，Lock提供了无条件的、可轮询的(tryLock方法)、定时的(tryLock带参方法)、可中断的(lockInterruptibly)、可多条件队列的(newCondition方法)锁操作。另外Lock的实现类基本都支持非公平锁(默认)和公平锁，synchronized只支持非公平锁，当然，在大部分情况下，非公平锁是高效的选择。

线程池的实现原理：https://blog.csdn.net/java_wxid/article/details/101844786

JUC并发包：

    volatile的三大特性：https://blog.csdn.net/java_wxid/article/details/97611028
    CompareAndSwap底层原理：https://blog.csdn.net/java_wxid/article/details/97611037
    AtomicReference原子引用：https://blog.csdn.net/java_wxid/article/details/97611046
    CountDownLatch倒计时器：https://blog.csdn.net/java_wxid/article/details/99168098
    CyclicBarrier循环栅栏：https://blog.csdn.net/java_wxid/article/details/99171155
    Semaphore信号灯：https://blog.csdn.net/java_wxid/article/details/99174538

ThreadLocal与Lock和Synchronize区别

ThreadLocal与Lock和Synchronize区别
ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。ThreadLocal采用了“以空间换时间”的方式，为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。同步机制采用了“以时间换空间”的方式，仅提供一份变量，让不同的线程排队访问。
如果一个代码块被synchronized关键字修饰，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待直至占有锁的线程释放锁。事实上，占有锁的线程释放锁一般会是以下三种情况之一：
占有锁的线程执行完了该代码块，然后释放对锁的占有；
占有锁线程执行发生异常，此时JVM会让线程自动释放锁；
占有锁线程进入 WAITING 状态从而释放锁，例如在该线程中调用wait()方法等。
synchronized 是Java语言的内置特性，可以轻松实现对临界资源的同步互斥访问。那么，为什么还会出现Lock呢？试考虑以下三种情况：
Case 1 ：
在使用synchronized关键字的情形下，假如占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法。这会极大影响程序执行效率。因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：tryLock(long time, TimeUnit unit)) 或者能够响应中断 (解决方案：lockInterruptibly())），这种情况可以通过 Lock 解决。
Case 2 ：
我们知道，当多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作也会发生冲突现象，但是读操作和读操作不会发生冲突现象。但是如果采用synchronized关键字实现同步的话，就会导致一个问题，即当多个线程都只是进行读操作时，也只有一个线程在可以进行读操作，其他线程只能等待锁的释放而无法进行读操作。因此，需要一种机制来使得当多个线程都只是进行读操作时，线程之间不会发生冲突。同样地，Lock也可以解决这种情况 (解决方案：ReentrantReadWriteLock) 。
Case 3 ：
我们可以通过Lock得知线程有没有成功获取到锁 (解决方案：ReentrantLock) ，但这个是synchronized无法办到的。
上面提到的三种情形，我们都可以通过Lock来解决，但 synchronized 关键字却无能为力。事实上，Lock 是 java.util.concurrent.locks包下的接口，Lock 实现提供了比 synchronized 关键字更广泛的锁操作，它能以更优雅的方式处理线程同步问题。也就是说，Lock提供了比synchronized更多的功能。但是要注意以下几点：
1）synchronized是Java的关键字，因此是Java的内置特性，是基于JVM层面实现的。而Lock是一个Java接口，是基于JDK层面实现的，通过这个接口可以实现同步访问；
2）采用synchronized方式不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而 Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致死锁现象。

关于读写锁：https://blog.csdn.net/java_wxid/article/details/99165717

后端高级