闭锁工作就像一道门,在门关闭的时候没有线程能通过,只有在门开时线程才会通过.(1)CountDownLatcha)  java中CountDownLatch类就是实现闭锁的工具,在其内有一个计数器(使用构造初始),当使用CountDownLatch的await方法会使当前线程阻塞,countDown会递减内部的计数,当计数为0的时候,所有CountDownLatch阻塞的线程才会一起开始继续执行.

首先明确一点Java是无法从死锁状态中恢复的.(1)线程锁死的条件:a)  线程存在互斥b)  至少有一个任务必须持有资源且正在等待获取一个当前被别的任务持有的资源c)  资源不能被任务抢占,任务必须把资源释放当做普通事件.d)  线程之间互相等待(2)实例:a)  一个单线程池,一个任务将另一个任务提交到同一个线程池中.并且等待另一个任务的结果,这就发生死锁.b)  A占有锁L,但是需要锁M,B

发布逸出(1)发布:发布是指将一个对象,使其引用储存到一个其他代码可以访问到的地方,在一个非私有方法返回这个引用,也可以把它传递到其他对象中.a)  发布最简单的就是将对象设置到公共静态域中b)  发布第二种简单的方式就是在一个公共方法内直接return对象的引用第三种的发布就很隐秘了.就是讲自身的对象引用发布到另一个对象的引用中.可能在构造中出现如此这就是this例如:这样source就持有Th

线程的四种状态1.新状态：线程已被创建但尚未执行（start()尚未被调用）。2.可执行状态：线程可以执行，虽然不一定正在执行。CPU时间随时可能被分配给该线程，从而使得它执行。3.死亡状态：正常情况下run()返回使得线程死亡。调用stop()或destroy()亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。4.阻塞状态：线程不会被分配CPU时间，无法执行。 线程的优先

1.Runnable接口  线程类都是实现Runnable接口的run方法2.Thread类  Thread类也是对Runnable的实现，线程的运行是，将Runnable的实现类交给Thread，Thread通过代理模式，在run方法中调用实现类的代理方法，Thread的start()方法开始线程的执行。  sleep(longmillis);sleep(longmillis,intnanos)

      在并发量很小的情况下，也许大家平时用到的HashMap比较多。我们知道HashMap是线程不安全的，在多线程使用HashMap进行put操作会引起死循环，导致cpu利用率接近100%（已测试模拟100000个线程执行以uuid为key，put值操作，cpu达到百分之90多）。HashTable是使用synchronized保证线程安全的，但是线程竞争激烈的情况下效率低，如线程1使用pu

[tutorialsite][1]死锁deadlock死锁是指两个或两个以上的进程在执行过程中，因竞争资源而造成的一种互相等待的现在，若无外力作用，它们都无法推进下去。再重提下竞态条件竞态条件（racecondition），从多线程间通信的角度来讲，是指两个或多个线程对共享的数据进行读或写的操作时，最终的结果取决于这些线程的执行顺序的情况。导致竞态条件的代码是关键区域这是一个严重的问题，因为死锁会

tutorialssiteLocksinjavaLocks(andothermoreadvancedsynchronizationmechanisms)arecreatedusingsynchronizedblocks,soitisnotlikewecangettotallyridofthesynchronizedkeyword.锁的实现是利用synchonized，wait()，notify()

虽是读书笔记，但是如转载请注明出处http://segmentfault.com/blog/exploring/..拒绝伸手复制党Thread线程的几种状态线程具有新建、可运行、阻塞、等待、定时等待、死亡六种。线程的状态完全包含了一个线程从新建到运行，最后到结束的整个生命周期，线程状态的具体信息如下：NEW（新建状态、初始化状态）：线程对象已经被创建，但是还没有被启动时的状态。这段时间就是在我们调

tutorialsite1tutorialsite2一个问题：每启动一个新线程都会有相应的性能开销(涉及到OS的交互：创建线程，销毁线程)，而且每个线程都需要给栈分配一些内存等等。这种代价随着新线程不断的创建，将会大大降低性能甚至使JVM崩溃。如何解决？使线程可以复用，执行完一个任务，并不被销毁，而是可以继续执行其他的任务。这样避免了创建以及销毁线程的代价以及线程过多造成内存消耗过度以及切换过度问

避免代码块受到并发访问的干扰java语言提供了两种机制实现这种功能Synchonized关键字（调用对象内部的锁）synchronized关键字自动提供一个锁以及相关的条件引入了ReentrantLock类。（显示锁）更好：JUC框架为这些基础机制提供了独立的类:线程池，或者高级一点专门做并发的工具的支持ReentrantLock类-锁Lock与synchronized区别Lock不是Java语言

tutorialssite并发Concurrency发展的历史单CPU，一次只能运行一个程序--多任务，一次同时运行多个任务（问题是每个任务不能永远占有资源或者CPU，不再使用资源或者CPU的程序需要释放掉自己的资源）--多线程，每个任务都有多线程进行处理，每个执行着的线程都可以当做是一个CPU。（问题是每个线程都执行相同的任务，因此同时读和写同一段内存，这会导致单线程不能出现的问题）举个例子：如

JAVA多线程与并发学习总结 1.     

转载自：http://lavasoft.blog.51cto.com/62575/115112   在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过Executor来启动线程比用Thread的start()更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。 &nb

http://www.blogjava.net/xylz/category/45607.htmlhttp://blog.csdn.net/andycpp/article/category/177882

一、多线程1、操作系统有两个容易混淆的概念，进程和线程。进程：一个计算机程序的运行实例，包含了需要执行的指令；有自己的独立地址空间，包含程序内容和数据；不同进程的地址空间是互相隔离的；进程拥有各种资源和状态信息，包括打开的文件、子进程和信号处理。线程：表示程序的执行流程，是CPU调度执行的基本单位；线程有自己的程序计数器、寄存器、堆栈和帧。同一进程中的线程共用相同的地址空间，同时共享进进程锁拥有的

一、多线程1、操作系统有两个容易混淆的概念，进程和线程。进程：一个计算机程序的运行实例，包含了需要执行的指令；有自己的独立地址空间，包含程序内容和数据；不同进程的地址空间是互相隔离的；进程拥有各种资源和状态信息，包括打开的文件、子进程和信号处理。线程：表示程序的执行流程，是CPU调度执行的基本单位；线程有自己的程序计数器、寄存器、堆栈和帧。同一进程中的线程共用相同的地址空间，同时共享进进程锁拥有的

java并发学习与实践——FutrueTask的使用示例并发模式中，有一个称做Future模式。啥是Future模式捏？

本文是学习网络上的文章时的总结，感谢大家无私的分享。CyclicBarrier类有一个整数初始值，此值表示将在同一点同步的线程数量。当其中一个线程到达确定点，它会调用await()方法来等待其他线程。当线程调用这个方法，CyclicBarrier阻塞线程进入休眠直到其他线程到达。当最后一个线程调用CyclicBarrier类的await()方法，它唤醒所有等待的线程并继续执行它们的任务。注意比较C

本文是学习网络上的文章时的总结，感谢大家无私的分享。CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await

本文是学习网络上的文章时的总结，感谢大家无私的分享。当一个线程想要访问某个共享资源，首先，它必须获得semaphore。如果semaphore的内部计数器的值大于0，那么semaphore减少计数器的值并允许访问共享的资源。计数器的值大于0表示，有可以自由使用的资源，所以线程可以访问并使用它们。packagechapter3; importjava.util.concurrent.Semapho

本文是学习网络上的文章时的总结，感谢大家无私的分享。读写锁重要的是写锁的使用，只用一个入口。下面是读写锁使用的例子packagechapter2; importjava.util.concurrent.locks.ReadWriteLock; importjava.util.concurrent.locks.ReentrantReadWriteLock; publicclassPricesIn

本文是学习网络上的文章时的总结，感谢大家无私的分享。Java提供另外的机制用来同步代码块。它比synchronized关键字更加强大、灵活。Lock接口比synchronized关键字提供更多额外的功能。在使用Lock时需要注意的是要释放Lock锁。packagechapter2; importjava.util.concurrent.locks.Lock; importjava.util.co

本文是学习网络上的文章时的总结，感谢大家无私的分享。其实很简单，大家看代码就知道是神马意思了。packagechapter2; importjava.util.Date; importjava.util.LinkedList; importjava.util.List; publicclassEventStorage{ privateintmaxSize; privateListstorag

本文是学习网络上的文章时的总结，感谢大家无私的分享。当你使用synchronized关键字来保护代码块时，你必须通过一个对象的引用作为参数。通常，你将会使用this关键字来引用执行该方法的对象，但是你也可以使用其他对象引用。通常情况下，这些对象被创建只有这个目的。比如，你在一个类中有被多个线程共享的两个独立属性。你必须同步访问每个变量，如果有一个线程访问一个属性和另一个线程在同一时刻访问另一个属性

本文是学习网络上的文章时的总结，感谢大家无私的分享。 每个方法声明为synchronized关键字是一个临界区，Java只允许一个对象执行其中的一个临界区。静态方法有不同的行为。只有一个执行线程访问被synchronized关键字声明的静态方法，但另一个线程可以访问该类的一个对象中的其他非静态的方法。你必须非常小心这一点，因为两个线程可以访问两个不同的同步方法，如果其中一个是静态的而另一个不是。如

本文是学习网络上的文章时的总结，感谢大家无私的分享。 1、工厂模式是最有用的设计模式。它是一个创造模式，还有他的目的是创建一个或者几个类对象的对象。有了这个工厂，我们有这些优势集中创建对象：更简单的改变了类的对象创建或者说创建这些对象的方式；更简单的为了限制的资源限制了对象的创建。更简单的生成创建对象的统计数据。2、Java提供一个接口，ThreadFactory接口实现一个线程对象工厂packa

本文是学习网络上的文章时的总结，感谢大家无私的分享。1、如果创建一个类对象，实现Runnable接口，然后多个Thread对象使用同样的Runnable对象，全部的线程都共享同样的属性。这意味着，如果你在一个线程里改变一个属性，全部的线程都会受到这个改变的影响。如果希望程序里的哥哥线程的属性不会被共享，Java并发API提供了一个很清楚的机制叫本地线程变量。2、Java并发API包括Inherit

本文是学习网络上的文章时的总结，感谢大家无私的分享。1、Java里有2种异常：检查异常：这些异常必须强制捕获她们或在一个方法里的throws子句中。未检查异常：这些异常不用强制捕获它们。2、在一个线程对象的run()方法里抛出一个检查异常，我们必须捕获并处理她们。因为run（）方法不接受throws子句。当一个非检查异常抛出，默认的的行为是在控制台写下stacktrace并退出程序。package

本文是学习网络上的文章时的总结，感谢大家无私的分享。1、Java有两种Thread：“守护线程Daemon”与“用户线程User”。用户线程：Java虚拟机在它所有非守护线程已经离开后自动离开；守护线程：则是用来服务用户线程的，如果没有其他用户线程在运行，那么就没有可服务对象，也就没有理由继续下去。2、setDaemon（booleanon）方法可以方便的设置线程的Daemon模式，true为Da

本文是学习网络上的文章时的总结，感谢大家无私的分享。1、在某些情况下，我们需要等待线程的终结。例如，我们可能会遇到程序在执行前需要初始化资源。在执行剩下的代码之前，我们需要等待线程完成初始化任务。为了达到此目的，我们使用Thread类的join()方法。当前线程调用某个线程的这个方法时，它会暂停当前线程，直到被调用线程执行完成。2、Java提供2种形式的join（）方法：Join(longmill

本文是学习网络上的文章时的总结，感谢大家无私的分享。1、Thread类的sleep方法，可以使线程睡眠。此方法接收一个整数作为参数，表示线程暂停运行的毫秒数。在调用sleep方法后，当时间结束时，JVM会安排他们CPU时间，线程会继续按指令执行。       另一种可能是使用一个有TimeUnit列举元素的sleep方法，使用线程类的sleep方法让当前线程睡眠，但是它接收的参数单位后会转成毫秒的

本文是学习网络上的文章时的总结，感谢大家无私的分享。1、如果线程实现的是由复杂算法分成的一些方法，或者他的方法有递归调用，那么我们可以用更好的机制来控制线程中断。为了这个Java提供了InterruptedException异常。当你检测到程序的中断并在run()方法内捕获，你可以抛这个异常。2、InterruptedException异常是由一些与并发API相关的Java方法，如sleep()抛

本文是学习网络上的文章时的总结，感谢大家无私的分享。1、一个多个线程在执行的Java程序，只有当其全部的线程执行结束时（更具体的说，是所有非守护线程结束或者某个线程调用System.exit()方法的时候），它才会结束运行。有时，你需要为了终止程序而结束一个线程，或者当程序的用户想要取消某个Thread对象正在做的任务。2、Java提供中断机制来通知线程表明我们想要结束它。中断机制的特性是线程需要

本文是学习网络上的文章时的总结，感谢大家无私的分享。Thread类的对象中保存了一些属性信息能够帮助我们辨别每一个线程，知道它的一些信息ID：每个线程的独特标示；Name：线程的名称；Priority：线程对象的优先级。优先级别在1-10之间，1是最低级，10是最高级。Status：线程状态。在java中，线程只有6种状态：new,runnable,blocked,waiting,timewait

本文是学习网络上的文章时的总结，感谢大家无私的分享。1、与每个Java语言中的元素一样，线程是对象。在Java中，我们有两种方式创建线程：a、通过直接继承thread类，然后覆盖run方法。b、构建一个实现Runnable接口的类，然后创建一个thread类对象并传递Runnable对象作为构造参数代码如下packagechapter; /** * *Description:它能创建和运行10个

1.     计算机系统使用高速缓存来作为内存与处理器之间的缓冲，将运算需要用到的数据复制到缓存中，让计算能快速进行；当运算结束后再从缓存同步回内存之中，这样处理器就无需等待缓慢的内存读写了。缓存一致性：多处理器系统中，因为共享同一主内存，当多个处理器的运算任务都设计到同一块内存区域时，将可能导致各自的缓存数据不一致的情况，则同步回主内存时需要遵循一些协议。乱序执行优化：为了使得处理器内部的运算单

非常不错的一篇文章，介绍java并发的1.     计算机系统使用高速缓存来作为内存与处理器之间的缓冲，将运算需要用到的数据复制到缓存中，让计算能快速进行；当运算结束后再从缓存同步回内存之中，这样处理器就无需等待缓慢的内存读写了。缓存一致性：多处理器系统中，因为共享同一主内存，当多个处理器的运算任务都设计到同一块内存区域时，将可能导致各自的缓存数据不一致的情况，则同步回主内存时需要遵循一些协议。乱

线程和进程:    线程又称为轻量级进程,和进程一样拥有独立的执行控制,由操作系统进行调度.区别是线程没有独立的存储空间,而是和所属进程中的其他线程共享一个存储空间,所以线程之间的通信较进程简单.    多线程大多时间我们不是在使用多个线程而是维护多个线程之间的协作.比如数据共享.   

守护线程    守护线程是指不是程序的核心线程意思是,如果所有非守护线程停止后核心线程也将终止,核心线程,守护线程一般作为后台线程为其他线程提供服务的.    判断是否为核心线程调用isDaemon()方法判断.设置线程为守护线程使用setDaemon()方法    记住守护线程派生出来的子线程也为守护线程线程组    线程组是一个Java特有的概念，在Java中，线程组是类ThreadGroup

首先,要说的是java中没有一种停止线程的方法是绝对安全的.线程的中断Thread.interrput()方法很容易给人一种误会,让人感觉是一个线程使另外一个正在运行的线程停止工作,但实际上interrput仅仅传递了请求中断的信息.线程自己会在下一个方便的时间中断.某些操作会接受这个请求时发出一个异常,比如wait,sleep.每一个Thread线程都有一个中断状态,是boolean型的当调用i

线程的四种状态1.新状态：线程已被创建但尚未执行（start()尚未被调用）。2.可执行状态：线程可以执行，虽然不一定正在执行。CPU时间随时可能被分配给该线程，从而使得它执行。3.死亡状态：正常情况下run()返回使得线程死亡。调用stop()或destroy()亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。4.阻塞状态：线程不会被分配CPU时间，无法执行。 线程的优先

首先明确一点Java是无法从死锁状态中恢复的.(1)线程锁死的条件:a)  线程存在互斥b)  至少有一个任务必须持有资源且正在等待获取一个当前被别的任务持有的资源c)  资源不能被任务抢占,任务必须把资源释放当做普通事件.d)  线程之间互相等待(2)实例:a)  一个单线程池,一个任务将另一个任务提交到同一个线程池中.并且等待另一个任务的结果,这就发生死锁.b)  A占有锁L,但是需要锁M,B

发布逸出(1)发布:发布是指将一个对象,使其引用储存到一个其他代码可以访问到的地方,在一个非私有方法返回这个引用,也可以把它传递到其他对象中.a)  发布最简单的就是将对象设置到公共静态域中b)  发布第二种简单的方式就是在一个公共方法内直接return对象的引用第三种的发布就很隐秘了.就是讲自身的对象引用发布到另一个对象的引用中.可能在构造中出现如此这就是this例如:这样source就持有Th

信号量(1)计数信号量可以控制同时访问某特定资源的活动数量,或者同时执行某一给定操作的数量.a)  信号量可以实现资源池(线程池)和规定无界容器的边界b)  信号量为1的可以作为特定线程的互斥锁(2)Java使用Semaphore类作为信号量类,acquire可以获取一个或多个量,release可以归还一个或者多个量关卡(1)关卡类似闭锁,但是关卡是需要所有线程到达一个状态后才能一起处理,而不是倒

(1)直接继承Thread类      直接继承Thread类并且覆盖重写run方法,然后new出此类使用start方法启动线程如下:publicclassMyThreadextendsThread{ @Override publicvoidrun(){ while(true){ System.out.println("MyThreadrun()method"); } } publicstatic

闭锁工作就像一道门,在门关闭的时候没有线程能通过,只有在门开时线程才会通过.(1)CountDownLatcha)  java中CountDownLatch类就是实现闭锁的工具,在其内有一个计数器(使用构造初始),当使用CountDownLatch的await方法会使当前线程阻塞,countDown会递减内部的计数,当计数为0的时候,所有CountDownLatch阻塞的线程才会一起开始继续执行.

(1)线程池的大小:N=cpu数量,U=目标cpu的使用率,W/C等待时间与计算时间比率                         线程池大小=N*U*(1+W/C)                         Runtime.getRuntime().availableProcessors()得到CPU数量              以上只是一般情况下.(2)自定义线程池ThreadP

    容器的遍历,这是个非常费时的同步,如果不同步可能会发出异常,因为你在检查后的第一时间不是输出这个值,而是由其他线程在你的容器内移除最后一个元素,而你正在为输出取得这个元素时就回得到一个异常.但是把整个遍历容器加锁后.其他增删改操作将在很长一段时间内无法进行,这严重影响了其他操作使其他操作无响应.简单的解决就是复制容器只在取得容器的部分加上同步.这样虽然开销大于以前,但是可以抽出cpu时间交

大多数类都是由其他类组合起来的。所以组合后的类是否是同步安全的有时候会让人很迷惑。(1)设计线程安全的类a)  确定对象状态由哪些变量构成b)  确定限制状态变量的不变约束c)  制定管理并发访问对象状态的策略.(2)数据限制为private,访问对象的方法设置为同步的可以有效的确保线程安全,且不要将数据发布到其他非线程安全的类中.发布到期望可用的范围内.(3)Java监视器模式保护对象,其实就是