西瓜游侠的博客

synchronized 和 Lock 的区别：Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现。synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生。而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁。Lock可以让等待锁的线程响应中断，而synchronized却不行。使用synchronized时，等待的线程会一直等

volatile的特性保证变量对所有线程的可见性，线程总能拿到最新的值；禁止指令重排；对任意单个volatile变量的读/写具有原子性，但是对于类似的volatile++这种复合操作不具有原子性。volatile的内存语义当写一个 volatile 变量时，JMM 会把该线程对应的本地内存中的共享变量值刷新到主内存。当读一个 volatile 变量时，JMM 会把该线程对应的本地内存置为无效，线程接下来将从主内存中读取共享变量最新的值。volatile是如何解决java并发中可见性

Java线程之间的通信由Java内存模型(JMM) 控制，JMM决定一个线程对共享 变量的写入何时对另一个线程可见。线程之间的共享变量存储在 **主内存（Main Memory）**中，每个线程都有一个私有的 本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。Java内存模型的抽象示意如图所示：...

JDK 版本：AdoptOpenJDK 11.0.10+91 基本概念ScheduledThreadPoolExecutor 是 j.u.c 内置的用于处理延时、周期性任务调度的线程池。它继承了 ThreadPoolExecutor 类同时实现了 ScheduledExecutorService 接口。由于要满足任务的延时、周期调度，在 ScheduledThreadPoolExecutor 中会对所有 Runnable 任务进行包装，包装成一个 RunnableScheduledFut.

JDK版本：AdoptOpenJDK 11.0.10+9参考：[Java多线程进阶（四十）—— J.U.C之executors框架：ThreadPoolExecutor](Java多线程进阶（四十）—— J.U.C之executors框架：ThreadPoolExecutor)1 基本概念ThreadPoolExecutor 是 j.u.c 提供的实现了 ExecutorService 接口的实现类，Executors 提供的很多线程池都是基于它来创建的。ThreadPoolExecutor 并.

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念j.u.c提供了一套完整的线程池框架，主要包括：Executor 接口 —— 执行器。ExecutorService 接口 —— 增强型执行器。ScheduledExecutorService 接口 —— 周期任务调度执行器。Executor（发音：一个在Q特儿）2 Executor 接口Executor 接口的目的是为了 解耦任务本身和任务的执行，只有一个execute(Runnable command) 方法.

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念LinkedBlockingDeque 实现了 BlockingQueue 接口，底层是基于 单链表 的实现。public class LinkedBlockingDeque<E> extends AbstractQueue<E> implements BlockingDeque<E>, java.io.Serializable { // 单链表首节点 .

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念j.u.c包提供的Condition接口，可以看作是对Object的wait()、notify()、notifyAll()的的替代，与Lock配合使用，一般用于线程间的通信。获取一个Condition 必须要通过Lock 的newCondition() 方法。该方法定义在接口Lock 下面，返回的结果是绑定到此 Lock 对象的新 Condition 对象。一个Lock对象可以有多个Condition对象，每个Condition.

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念ArrayBlockingQueue 实现了 BlockingQueue 接口，底层是基于 数组 的实现。public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable { // 队列中的元素 fin.

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念BlockingQueue是JDK1.5引入的一个阻塞队列接口：public interface BlockingQueue<E> extends Queue<E>BlockingQueue继承与Queue接口，提供了一些阻塞方法。BlockingQueue 最显著的特性是：当线程向队列中插入元素的时候，如果队列已满，则阻塞线程，直到队列有空闲位置（非满）；当线程从队列中取出元素的时候（删除队列.

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念CopyOnWriteArraySet 是为 “读多写少” 场景设计的并发容器，其特点如下：适用于高并发场景列表型容器没有重复的数据利用 “写时复制” 思想，保证读/写同时进行不会冲突只有当多个线程同时进行写操作的时候，才需要同步内部使用CopyOnWriteArrayList 对象实现功能2 内部原理CopyOnWriteArraySet 内部引用了一个 CopyOnWriteArrayList 对象，以 “组.

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念CopyOnWriteArrayList是一种为 “读多写少” 的场景设计的列表型并发容器，其特点如下：适用于高并发场景列表型容器利用 “写时复制” 思想，保证读/写同时进行不会冲突只有当多个线程同时进行写操作的时候，才需要同步“写时复制” 的思想是，当我们需要修改（增/删/改）列表中的元素时，不直接进行修改，而是先将列表复制一份，然后在新的副本上进行修改，修改完成之后，再将引用从原列表指向新列表。2 内部原理.

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念ConcurrentSkipListSet是一种为并发场景设计的有序Set，其特点如下：适用于高并发场景元素是有序的、唯一的内部通过引用一个ConcurrentSkipListMap对象来实现功能添加的值不能为null2 内部原理ConcurrentSkipListSet内部通过引用一个ConcurrentSkipListMap对象来实现功能，因为ConcurrentSkipListMap的key就是一个有序的、无.

JDK版本：AdoptOpenJDK 11.0.10+91 基本概念ConcurrentSkipListMap是在JDK 1.6中新增的，为了对高并发场景下的有序Map提供更好的支持，它有几个特点：高并发场景key是有序的添加、删除、查找操作都是基于跳表结构（Skip List）实现的2 跳表（Skip List）跳表（Skip List）是一种类似于链表的数据结构，其查询、插入、删除的时间复杂度都是 O(logn)。在传统的单链表结构中，查找某个元素需要从链表的头部按顺序遍历，.

参考：Java并发编程的艺术JDK版本：AdoptOpenJDK 11.0.10+91 概念Phaser（阶段器，发音：非泽尔），是1.7引入的，用于分阶段执行任务的场景。Phaser中定义了一些概念：phase（阶段）类似于CyclicBarrier，Phaser也有栅栏的概念。在Phaser中，栅栏叫做phase（阶段），在任意的时间点，Phaser只处于某一个phase（阶段），初始为0，最大达到Integer.MAX_VALUE，然后重新归零。当所有的parties（参与者）都到.

参考：Java并发编程的艺术JDK版本：AdoptOpenJDK 11.0.10+91 概念Exchanger（交换器），可以用于线程之间交换数据。它提供一个同步点，在这个同步点两个线程可以交换彼此的数据。这两个线程通过exchange()方法交换数据， 如果第一个线程先执行exchange()方法，它会一直等待第二个线程也执行exchange()方法，当两个线程都到达同步点时，这两个线程就可以交换数据。因此使用Exchanger的重点是成对的线程使用exchange()方法，当有一对线程达到.

参考：Java并发编程的艺术JDK版本：AdoptOpenJDK 11.0.2+91 概念Semaphore（信号量），可以用来控制同时访问特定资源的线程数量，常用于限流场景。Semaphore接收一个int整型值，表示许可证数量。线程通过调用acquire()获取许可证，执行完成之后通过调用release()归还许可证。获取不到许可证的线程将会阻塞。Semaphore支持公平锁和非公平锁。2 方法Semaphore提供了一些方法，如下：方法说明acquire().

参考：Java并发编程的艺术JDK版本：AdoptOpenJDK 11.0.2+91 概念2 方法CountDownLatch 提供了一些方法：方法说明await()使当前线程进入同步队列进行等待，直到latch的值被减到0或者当前线程被中断，当前线程就会被唤醒。await(long timeout, TimeUnit unit)带超时时间的await()。countDown()使latch的值减1，如果减到了0，则会唤醒所有等待在这个latch上的线程。.

参考：Java并发编程的艺术JDK版本：AdoptOpenJDK 11.0.2+91 概念CountDownLatch允许一个或者多个线程去等待其他线程完成操作。CountDownLatch接收一个int型参数，标识要等待的工作线程的个数。当然也不一定是多线程，在单线程中可以用这个int型参数标识多个操作步骤。2 方法CountDownLatch2 例子下面代码演示2个等待线程通过CountDownLatch去等待3个工作线程完成操作：public class CountDownLa.

参考：Java并发编程的艺术JDK版本：AdoptOpenJDK 11.0.2+9ReentrantLock 可重入锁：支持一个线程对共享资源的重复加锁。支持获取锁时候的公平和非公平性选择。1 可重入可重入是指：任意线程在获取到锁之后能够再次获取该锁而不会被锁阻塞。ReentrantLock实现可可重入锁的逻辑，解决两个关键问题：**支持线程再次获取锁。**锁需要识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取锁。**锁的最终释放。**通过计数器记录锁被重复获取的次.

参考：Java并发编程的艺术1 AQS 队列同步器队列同步器（AbstractQueuedSynchronizer，AQS）是用来构架锁或者其他同步组件的基础框架。它是面向锁的实现者的，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待和唤醒等底层操作，大大降低了实现一个可靠的锁或者同步组件的门槛。2 AQS 提供的接口AQS是基于模板方法模式设计的。使用者需要继承同步器并重写指定的方法来操作同步状态，使用的时候要调用同步器提供的模板方法。下面对同步器提供的方法一一说明。2.1 访问.

参考：Java并发编程的艺术线程间通信的方式有：通过volatile和synchronized关键字等待/通知机制管道输入/输出流Thread.joinThreadLocal线程本地变量1 通过volatile和synchronized关键字Java支持多个线程同时访问一个对象或者对象的成员变量。每个线程在自己的本地内存中都有共享变量的一份拷贝。volatilevolatile关键字用来修饰变量。任何对该变量的访问均需要从共享内存中获取，任何对该变量的修改必须同步刷新到共.

双重检查锁定的典型例子，如下：public class DoubleCheckedLocking { private static Instance instance; /** * 双重检查锁定 */ public static Instance getInstance() { if (instance == null) { // 1、第一次检查 synchroniz

1 概念在Java多线程编程中，通过ThreadLocal实现了线程本地变量机制，通过空间换时间达到了线程隔离的目的。但是，现在有这样一个需求：父线程中的线程本地变量需要传递给子线程使用。针对这种情况，通过ThreadLocal是无法完成的，因为ThreadLocal中保存的是线程的本地变量，父线程的线程本地变量只有自己能拿到，子线程无法拿到。如下代码演示：package com.tao....

转载：http://www.importnew.com/21353.html1. 锁优化的思路和方法锁优化的思路和方法有以下几种：减少锁持有时间减小锁粒度锁分离锁粗化锁消除1.1 减少锁持有时间public synchronized void syncMethod(){ othercode1(); mutextMethod();

转载：http://www.jianshu.com/p/9218692cb2091、线程间的通信方式使用全局变量 主要由于多个线程可能更改全局变量，因此全局变量最好声明为volatile。使用消息队列实现通信 在Windows程序设计中，每一个线程都可以拥有自己的消息队列（UI线程默认自带消息队列和消息循环，工作线程需要手动实现消息循环），因此可以采用消息进行线程间通信sendMessage

转载：http://www.cnblogs.com/leesf456/p/5291484.html1、volatile1.1 介绍关键字volatile是Java虚拟机提供的最轻量级的同步机制。 当一个变量定义为volatile时，它将具备两种特性：（1）可见性；（2）禁止指令重排序。 可见性 当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即获得的，但是基于volati

Java死锁的简单例子两个线程互相占有对方需要的资源而不释放，便形成了死锁。代码如下： Program.java/** * 程序类 * @author michael * */public class Program implements Runnable { //两个静态的资源 public static Object obj1 = new Object();

ConcurrentHashMap中的putIfAbsent方法的使用以及返回值的含义 public V putIfAbsent(@NotNull K key, @NotNull V value)putIfAbsent方法主要是在向ConcurrentHashMap中添加键—值对的时候，它会先判断该键值对是否已经存在。如果不存在（新的entry）

转载：http://www.cnblogs.com/skywang12345/p/3544116.html转载：http://www.cnblogs.com/dolphin0520/p/3949310.html转载：http://blog.csdn.net/linchunquan/article/details/22382487        创建线程有2种方式，一种是直接继承

转载：http://www.cnblogs.com/dolphin0520/p/3920373.htmlJava并发编程：volatile关键字解析　　 volatile这个关键字可能很多朋友都听说过，或许也都用过。在Java 5之前，它是一个备受争议的关键字，因为在程序中使用它往往会导致出人意料的结果。在Java 5之后，volatile关键字才得以重获生机。

package Condition;import java.util.LinkedList;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * 仓库类Storag

基础知识之一：锁的类型锁从宏观上分为：（1）乐观锁；（2）悲观锁。（1）乐观锁乐观锁是一种乐观思想，即认为读多写少，遇到并发写的可能性低，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，采取的方式是在写时先读出当前版本号，然后加锁操作（比较跟上一次的版本号，如果一样则更新），如果失败则要重复读-比较-写的操作。java中的乐观锁基本都是

转载：http://blog.csdn.net/xiangwanpeng/article/details/54972952sleep()　　sleep()方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，进入阻塞状态，该方法既可以让其他同优先级或者高优先级的线程得到执行的机会，也可以让低优先级的线程得到执行机会。但是sleep()方法不会释放“锁标志”，也就是说如果有sync

1 定义ThreadLocal是存储线程局部变量的容器。它为每一个使用该变量的线程都提供了一个变量值的副本，是Java中一种较为特殊的线程绑定机制。每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本发生冲突。2 原理分析在Java中，Thread类代表线程。查看Thread源码，如下：public class Thread implements Runnable { ...

synchronized (this)原理涉及两条指令：（1）monitorenter 每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下： 1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

1、Java实现多线程主要有三种方式：（1）继承Thread类（2）实现Runnable接口（3）使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。2、方式一：继承Thread类Thread类本质上也是实现了Runnable接口的一个类，它代表一个线程的实例。启动线程的唯一方法就是通过T

转载：http://blog.163.com/xh_ding/blog/static/193903289201341685931689在Java的多线程编程中，java.lang.Thread 类型包含了一些列的方法start(), stop(), stop(Throwable) and suspend(), destroy() and resume()。通过这些方法，我们可以对线程进行方便的操作，

转载：http://www.cnblogs.com/skywang12345/p/3479024.html线程状态图说明：线程共包括以下5种状态。新建状态(New)：线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。就绪状态(Runnable)： 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程

1、java多线程（一个优秀的博客）http://www.cnblogs.com/skywang12345/p/java_threads_category.html2、线程状态图http://www.cnblogs.com/skywang12345/p/3479024.html3、Callable、Future、FutureTaskhttp://blog.csdn.net/hbtj_1216/art