tomorrow_fine的博客

ArrayBlockingQueue最核心的实现就是一把锁，两个条件。具体看源码如下： /** Main lock guarding all access */ final ReentrantLock lock; /** Condition for waiting takes */ private final Condition notEmpty; /** Condition for waiting puts */ private final Condit

ReentrantReadWriteLock是一把可重入读写锁，提高了读的性能。读写锁时如何实现了呢。其实读写锁还是通过一个compareAndSet实现的，只是里面的state的含义不一样了，原先是表示线程的重入次数，现在对该变量做了拆分。高16位表示读线程的重入次数，第16位表示写线程的重入次数。下面我们看几个变量和方法 static final int SHARED_SHIFT = 16; //1 0000 0000 0000 0000 用于读线程重入一次 .

关键字volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。1.先做一个实验：    * 源码：           public class RunThread extends Thread{        private boolean isRunning=true;        public boolean isRunnin

等待/通知机制的实现1. 概述    * 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，        该方法用来将当前线程置入"预执行队列"中，并且在wait()所在的代码行处停止执行，        直到接到通知或被中断为止。在调用wait()之前，线程必须获得该对象的对象级别锁，        即只能在同步方法或同步块中调用

1.一生产与一消费：操作值    * 屁话没有，直接看例子        public class P {            private String lock;            public P(String  lock){                super();                this.lock=lock;           

通过管道进行线程间通信    * 在Java语言中提供了各种各样的输入/输出流Stream，使我们能够狠方便地对数据进行操作，其中管道        流式一种特殊的流，用于在不同线程间直接传输数据。一个线程发送数据到输出管道，另一个线程        从输入管道中读数据。通过使用管道，实现不同线程间的通信。    * 在java的JDK中提供了4个类来使线程间可以进行通信

直接看例子：public class DealThread implements Runnable{ public String username; public Object lock1=new Object(); public Object lock2=new Object(); public void setFlag(String username){

如果一个对象作为同步代码块的对象，那么该对象同步的代码段和该对象内部通过同步方法或者自身对象的代码段会被同步。看例子：public class OutClass { static class InnerClass1{ public void method1(InnerClass2 class2){ String threadName=Th

变量值的共享可以使用public static变量的形式，所有的线程都使用同一个public static变量。如果想实现每一个线程都有自己的共享变量。JDK中提供的类ThreadLocal正是为了解决这样的问题。类ThreadLocal主要解决的就是每个线程绑定自己的值。1. 方法get()与nullpublic class Run { public static

使用类InheritableThreadLocal可以在子线程中取得父线程继承下来的值。看栗子：public class Tools { public static InheritableThreadLocalExt t1=new InheritableThreadLocalExt();}public class InheritableThreadLocalE

Lock的使用1.使用ReentrantLock类    * 在java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类        也能达到同样的效果，并且再扩展功能上也更加强大，比如有嗅探锁定，多路分支通知等功能，而且在使用上也比        synchronized更加的灵活。   

线程对象在不同的运行时期有不同的状态，状态信息就存在于State枚举类中，    * public static enum Thread.State extends Enum    线程状态，线程可以处于下列状态之一        * NEW            至今尚未启动的线程处于这种状态        * RUNNABLE            正在Java虚拟机中

一.Java并发基础当一个对象或变量可以被多个线程共享的时候，就有可能使得程序的逻辑出现问题。 在一个对象中有一个变量i=0，有两个线程A，B都想对i加1，这个时候便有问题显现出来，关键就是对i加1的这个过程不是原子操作。要想对i进行递增，第一步就是获取i的值，当A获取i的值为0，在A将新的值写入A之前，B也获取了A的值0，然后A写入，i变成1，然后B也写入i，i这个时候依然是1. 当然j

产生原因 当某一段程序提交了一个请求，期望得到一个答复。但非常不幸的是，服务程序对这个请求的处理可能很慢。比如，这个请求可能是通过互联网、HTTP或者Web Service等并不太高效的方式调用的。在传统的单线程环境下，调用函数是同步的，也就是说它必须等到服务程序返回结果后，才能进行其他处理。解决方式 请求本身仍然需要很长一段时间来处理。但是，服务程序不等数据处理完成便立即返回客户端一个伪...

为了节省系统在并发时不断创建和销毁线程所带来的额外开销，就需要引入线程池。线程池的基本思想是，线程使用完后并不销毁，而是一直处于等待状态，如果下一个任务进入，可以再使用这个线程执行，这样就减少了线程的创建和销毁。 首先是线程池的实现：package com.mr.smart.future.simplethreadpool;import java.util.List;import j...

public class CounterPoolExecutor extends ThreadPoolExecutor { private AtomicInteger count = new AtomicInteger(0);//统计执行次数 private long startTime = System.currentTimeMillis(); private Strin...

在将任何数据类型作为同步锁时，需要注意的是，是否有多个线程同时持有锁对象，如果同时持有相同的锁对象，则这些线程之间就是同步的；如果分别获得锁对象，这些线程直接就是异步的1. 数值型数据    直接看例子，然后再解释：    public class MyService {    private String lock="123";    public void testMe

sleep() & interrupt()线程A正在使用sleep()暂停着: Thread.sleep(100000);如果要取消他的等待状态,可以在正在执行的线程里(比如这里是B)调用    a.interrupt();令线程A放弃睡眠操作,这里a是线程A对应到的Thread实例执行interrupt()时,并不需要获取Thread实例的锁定.任何线程在任何时刻,都可以

class InnerThread1{ private int countDown=5; private Inner inner; private class Inner extends Thread{ Inner(String name) { super(name); start(); }

join()方法可以让原来并列执行的线程，顺序执行，比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。如果对A线程使用interrupt()方法，则join()方法的低啊用可以被中断。class Sleeper extends Thread{ private int duration; public Sleeper(String n

lock()方法加锁，unlock()方法释放锁。tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，

涂完蜡才能抛光，抛光完又可以涂蜡class Car{ private boolean waxOn=false; /** * 涂蜡 */ public synchronized void waxed(){ waxOn=true; notify(); } /** * 抛光 */

notifyAll()调用时，并非唤醒所有的等待线程，而是当nofityAll()因某个特定锁而被调用时，只有等待这个锁的任务才会被唤醒。class Blocker{ synchronized void waitingCall(){ try { while(!Thread.interrupted()){ wai

一共有100个盒子，每个盒子中有一定数量的能量，每个线程持有一个盒子，向其他盒子中注入能量，实现能量守恒。public class EnergySystem { //能量盒子，能量存储的地方 private final double[] energyBoxes; private final Object lockObj=new Object(); /**

考虑这样一个饭店，他有一个厨师和一个服务生，然后服务生必须等待厨师准备好食物，当厨师准备好食物时，他会通知服务生，然后服务生上菜，然后返回继续等待。/** * 食物 */class Meal{ private final int orderNum; public Meal(int orderNum){ this.orderNum=orderNum;

Condition的await()方法void await() throws InterruptedException导致当前线程等到发信号或interrupted 。与此相关的锁Condition以原子方式释放，并且当前线程的线程调度目的就退出，一直处于休眠状态的四两件事发生对象 ：一些其它线程调用signal()方法本Condition和当前线程碰巧被选择作

方法：booleanadd(E e)将指定的元素插入到此队列中，如果可以立即执行此操作而不违反容量限制， true在成功后返回 IllegalStateException如果当前没有可用空间，则抛出IllegalStateException。 booleancontains(Object o)如果此队列包含指定的元素，则返回 true 。

通过PipedWriter类小姑娘管道中写数据 PipedReader类允许不同任务从同一管道中读取数据，如果当前没有数据就阻塞，等待数据的到来。并且PiPedReader 类与普通I/O之间有重要的差异，可以被中断。class Sender implements Runnable{ private Random rand=new Random(47); pri

假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉。因为用一只餐叉很难吃到意大利面，所以假设哲学家必须用两只餐叉吃东西。他们只能使用自己左右手边的那两只餐叉。哲学家就餐问题有时也用米饭和筷子而不是意大利面和餐叉来描述，因为很明显，吃米饭必须用两根筷子。哲学家从来不交谈，

CountDownLatch用来同步一个或多个 任务，强制他们等待由其他任务执行的一组操作完成。用法：给CountDownLatch对象设置一个初值，任何在这个对象上调用await()的方法都将阻塞，等待这个计数值为0，可以由其他线程在这个对象调用countDown()来减少这个计数值，计数值不能被重置。countDown()不会造成阻塞。示例：/** * 完成初始化

转自：http://blog.youkuaiyun.com/lufeng20/article/details/24314381ThreadLocal是什么　　早在JDK 1.2的版本中就提供Java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。　　当使用ThreadLocal维护

interrupted():测试当前线程是否已经中断（当前正在执行的线程，是静态方法）。isInterrupted():测试线程是否已经中断。（对象线程）。interrupted()方法具有清除状态的功能，isInterrupted()并未清除状态标志。示例：public class Run { public static void main(String[] args

java很多停止线程的方法不被推荐，下面介绍用interrupt停止线程，interrupt停止线程的原理就是打一个标记（初始为false），在run方法中运行时一直去判断这个标记，如果标记变为true,我们就选择不再执行，这样就达到了，停止的效果，但是这样仅仅是结束了本次循环，并没有停止线程往下执行，如果，想直接跳出，可以用异常实现。先介绍停止循环：public class

优先级的高低只是说明线程执行频率的高低，并不会导致线程得不到执行，优先权不会导致死锁示例：public class SimplePriorities implements Runnable{ /** * 倒计时变量 */ private int countDown=5; private volatile double d; /**