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

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

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

如果数据是非原子性操作,那么必须实现线程的同步化.在多线程的程序中,不建议使用惰性初始化(检查在运行)比如if(XX==null){returnnewXX}这种操作.PS:原子操作:指的是单独的,不可分割的操作去执行.比如A线程和B线程,从A线程的角度来看,当其他线程执行B线程的时候,要么B完全执行完,要么一点都没有执行;在java中i++这种操作并不是原子性的,它分为3个步骤完成,读取i值i+1

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

基于线程的服务,典型的就属于线程池了.这些服务通常的一点是,它们存在的时间通常比创建它们的方法存在的时间更久一些.程序拥有服务,服务拥有线程,但是程序并不一定拥有线程,因此程序不应该试图直接停止服务中的线程.所以服务应该提供控制其内部线程的生命周期的方法.(如同线程池ExecutorService的shutdown/shudownNow),不要发布线程给程序.让程序多管闲事.对于线程持有的服务,只

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

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

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

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

实现并发最直接的方式是在操作系统级别使用进程。   并发任务彼此隔离的编程语言，被称为函数型语言，例如：erlang。   Java的线程机制是抢占式的，这表示调度机制会周期性地中断线程，将上下文切换到另一个线程，从而为每个线程都提供时间片，使得每个线程都会分配到数量合理的时间去驱动它的任务。（协作多线程）   线程的底层机制：切分CUP时间，但通常你不需

Executor框架介绍 1、Executor框架提供了一个灵活的线程池实现，防止应用程序过载而耗尽内存。它是基于生产者-消费者模式的，提交任务的线程是生产者，执行任务的线程是消费者。 2、线程池   newFixedThreadPool创建一个定长的线程池，每当提交一个任务就创建一个线程，直到达到池的最大长度，这是线程池会保持长度不再变化（如果一个线程由于非预期的Exce

《Java Concurrency in Practice》学习笔记：   Q：Thread.sleep()方法什么时候触发InterruptedException？ A：线程执行start()方法启动后，当执行sleep()方法的时候，线程又执行了interrupt()方法，会触发InterruptedException()     public cla

之前的线程池已实现了基本的功能：运行每一个线程，而且测试了一下，大约速度是ThreadPoolExecutor的1.5倍（当然，这是有充分的理由的，后文会提到） 之后的版本将准备是实现“优雅退出”和优化（非阻塞）空闲线程队列了，这个步骤想了很久，发现了很多的问题（包括准备的实现方法也在这里列一下）： 1.初步构思了几个方法 void shutDown():该方法将让池不再接受任

首先得描述下什么是JCSP：CSP是CommunicatingSequentialProcesses的缩写在ibm的developerworks中国上学习java的并发编程时无意发现的，因为在之前的多线程编程实践中，调试一个多线程的bug都花了大量的时间，所以一直想找点工具或者技巧来学习一下然后就发现了这个玩意儿，这是JCSP在ibm的地址：并发专题JCSP第一部分JCSP第二部分JCSP第三部分

一直都知道有两个jvm，一个是server，一个是client，server适合做server，client合适做client，认识也就停留在这里了 最近在练习玩并发的程序，一时手痒，试了一下-server，居然出来的数据如此惊人，相差近100倍 先大概说一下代码的功能，对了，还要说一点，该测试只占用cpu 1.1千万个任务，任务是将不断地加一个随机数，加10000遍，随机数产生的方

没找到什么好工具，也没得到好建议，好技巧，只能自己摸索了 一步步优化把 先是优化测试代码 加的内容不多，但挺关键的 测试要模拟的是一个平稳的任务下发过程（如同现实生活中的），所以一下子将所有任务丢到队列中是很不对的，而且数量一大，堆就满了 经过多次测试，决定通过让主线程每发送n个，就休息一段时间来降低主线程的下发频率 以达到平稳的目的 这样设置之后，再适当调一下，就可

在写线程池的时候，遇到了很多的问题，特别是happen-before应该怎么去理解，怎么去利用，还有reorder，哪些操作有可能会被reorder？在这一点上，发现其实《concurrencyinpractice》也没描述得太清晰。在网上搜了一遍，发现JSR133的faq相对而言，还算稍微解释了一下，发现JSR133其实也就40多页，所以也就顺带看了一遍，因为大部分的内容都比较简单(越往后看发现

  Jsr133地址：http://www.cs.umd.edu/~pugh/java/memoryModel/jsr133.pdf 原文的地址：http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html JSR 133 (Java Memory Model) FAQJeremy Manson and Brian Go

Java并发编程实践 电子工业出版社 读书笔记： 1、volatile变量理解    写入volatile变量时就像退出同步块,读取volatile变量时就像进入同步块。volatile变量使用也存在好多限制，它通常被当作完成、中断、状态的标记使用。volatile变量只保证可见性，但不保证原子性。所以自增操作就不能依赖volatile，除非只有一个线程对它进行写操

到过北京上地的都会知道，上地城铁往西走有一个很大的上地环岛，旁边是中关村发展大厦，第一次到北京的时候还给了小弟一番挺大的感触 经常从环岛这里经过，总会思考一个问题：北京地价这么贵，为什么在这里要建一个这么大的环岛呢？环岛到底有什么作用呢？解决交通拥塞？为行人方便？还是别的原因？ 在百度百科可以搜到:是为了减少交通（和谐）事故的发生。 还有别的好处吗？ 先看看普通的十字路口，

在看书的时候看到了一个观察死锁的工具TDA（ThreadDumpAnalysis）看了半天，才知道这玩意儿需要由jvm产生一个ThreadDump这个ThreadDump跟之前看到的HeapDump也不是一回事windows下是ctrl+break触发，unix下是ctrl+\或者kill-QUITpid触发默认是输出到System.out，当然，你可以重定向的还有一个简单方便快捷的方法：Java

第二步，是实现一个线程池 因为之前看书的时候留了个心眼，看线程池相关的内容的时候特意没去研究JDK的实现 因为学跟做不是一码事，写一个线程池，算是给自己看完并发实践这书的一个练习吧 废话不多说，练习开始 首先，整理一下要实现的功能，或者说要注意的元素 1.实现Executor接口 2.实现一个等待队列（可否配置，优先级等） 3.是否需要预启动线程（可否配置） 4.执行开

看了几个月的《Java Concurrency in Practice》到了今天终于算可以收尾了，之前留下的看不懂的代码，现在也基本明晰了一些 全书介绍了很多细节问题，很多注意的点，很多原则性问题，个人感觉，无论看几遍，都是值得的。但很多都是一些需要去记忆的东西，这个是需要经验的积累的。 真正想在思考上，在设计上得到更大的提高，看来必然是要落在了concurrent包的数个同步器的实现的分

package philosophers; //Chopsticks for dining philosophers public class Chopstick { private boolean taken=false; public synchronized void take() throws InterruptedException { while(taken)

   消费者是LiftOffRunner，他将每个LiftOff对象从BlockingQueue中推出并直接运行，即通过显示的调用run（），使用自己的线程来运行，而不是为每个任务启动一个新线程 package producer_consumer_Queue; import java.io.BufferedReader; import java.io.IOExce

package producer_consumer1; import java.util.concurrent.*; import com.sun.org.apache.xalan.internal.xsltc.compiler.sym; /** * The produer-consumer approach task cooperation * @author wawa

线程：设置线程名称方便排错，对线程中断作出恰当的响应。线程副本：ThreadLocal它是localvariable（线程局部变量）。它的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本。线程资源同步机制：JVM把对于workingmemory的操作分为了use、assign、load、store、lock、unlock,对于mainmemory的操作分为了read、write、l

一、创建任务 任务可以理解为一段独立执行的代码，它完成一定的功能。在Java5及以上版本中不仅可以利用Runnable接口，还可以利用Callable接口。   两种任务的区别：Runnable的run()方法完成的任务是没有返回值的-void   而Callable的call()方法完成的任务是有返回值的-返回值有接口的泛型来制定 二、执行任务 通过java.util.concurrent.Ex

在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过Executor来启动线程比用Thread的start()更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。 一、创建任务 任务就是一个实现了Runnable接口的类。创建的时候实run方法即可。 二、执行任务 通过java.util

clojure并发学习 1： ref 抽象协调的、同步的可变状态， 利用STM来实现    创建一个ref    (def r (ref {}))

初学线程的教程 http://java.chinaitlab.com/line/778508.html 1 线程单独开辟的资源：寄存器、堆栈 2 // 开始线程 public void start( ); public void run( ); // 挂起和唤醒线程 public void resume( ); //

Java5并发学习 在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。