JAVA基础：java线程小结

会计考友 · 发表于 2012-8-4 12:37:27

　1, 为什么wait与notify之前必须要加synchronized? 　　答案其实很简单，也是为了防止等待-通知机制出现race condition
　　为什么会出现race condition ?
　　答：对象在被wait之前已经被另一线程notify , 之后的wait 会永久停止,并导致deadlock(死锁)
　　理想情况：
　　1, 第一个线程判断该对象是否要wait
　　2, 第一个线程将对象wait
　　3, 第二个线程再将对象notify
　　实际情况
　　1, 第一个线程判断该对象是否要wait
　　2, 第二个线程将对象notify
　　3, 第一个线程将对象wait
　　为了防止这些情况，才需要在wait与notify之前加synchronized
　　java 代码
　　A a = A.getInstance();//单例对象,同一份实例不销毁
　　synchronized (a) {
　　a.wait();
　　}
　　-------------------------------另一线程
　　A a = A.getInstance();
　　synchronized(a) {
　　a.notify();
　　}
　　等待-通知机制必须与sychronized一起用,否则自身也会有 race condition.
　　2, 静态同步方法与非静态同步方法的区别
　　有时，我们经常会碰到这样的代码！
　　业务逻辑的封装类:
　　public class Logic {
　　　　private static final Log log = LogFactory.getLog(Logic.class);
　　　　private static Logic logic;
　　　　private Logic() {}
　　　　public static Logic getInstance() {
　　　　　　if (null == logic) {
　　　　　　　　logic = new Logic();
　　　　　　}
　　　　　　return logic;
　　　　}
　　　　public static synchronized void testStatic() {
　　　　　　log.info(Thread.currentThread().getName() + " : static method is running");
　　　　}
　　　　public synchronized void testNonStatic() {
　　　　　　log.info(Thread.currentThread().getName() + " : non static method is running");
　　　　}
　　}
　　非静态方法的执行:
　　public class ThreadRun1 extends Thread {
　　　　private static final Log log = LogFactory.getLog(ThreadRun1.class);
　　　　public void run() {
　　　　　　Logic logic = Logic.getInstance(); // object reference
　　　　　　try {
　　　　　　　　Thread.sleep(3000);
　　　　　　} catch (InterruptedException e) {
　　　　　　　　log.error("some exceptions occured :", e);
　　　　　　}
　　　　　　logic.testNonStatic();
　　　　　　logEnd();
　　　　}

　　　　private void logEnd() {
　　　　　　log.info("thread run1 end");
　　　　}
　　}

会计考友 · 发表于 2012-8-4 12:37:28

　　静态类方法的执行</p>　　public class ThreadRun2 extends Thread {
　　　　private static final Log log = LogFactory.getLog(ThreadRun1.class);
　　　　public void run() {
　　　　　　Logic.testStatic(); // class static reference
　　　　　　try {
　　　　　　　　Thread.sleep(5000);
　　　　　　} catch (InterruptedException e) {
　　　　　　　　log.error("some error ocuur :", e);
　　　　　　}
　　　　　　logEnd();
　　　　}
　　　　private void logEnd() {
　　　　　　log.info("thread run2 end");
　　　　}
　　}
　　测试类
　　public class TestThread {
　　　　/**
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　ThreadRun1 run1 = new ThreadRun1();
　　　　　　run1.start();
　　　　　　ThreadRun2 run2 = new ThreadRun2();
　　　　　　run2.start();
　　　　}
　　}
　　现在有2根线程，其中一根会调用testStatic() , 而另一根会在testStatic未执行结束前调用testNonStatic！
　　那么，按照多线程同步原则，该对象会在调用testStatic()方法时被锁定，而该方法未结束前如果调用testNonStatic()方法，则必须要等待第一个线程执行完后，才可以执行继续执行！
　　但是，实际情况是两线程可同时被调用！
　　区别在于，前者是静态的，不需要实例化即可调用，那么既然连实例化的对象都没创建，何来锁住对象呢！
　　大家都知道，静态的方法一般都是直接调用“类.方法”来执行的，因此，调用testStatic锁住的其实是类！（锁住类不等于锁住该类实例的对象！）
　　总结：每个class只有一个线程可以执行静态同步方法，每个类的对象，只有一个线程可以执行同步方法！当对象实例调用同步方法，而同步方法中又调用了class的静态同步方法，其实此次调用一共锁住了2个不同的对象监视器！
　　Class级别的锁与Object级别的锁是不一样的, 两者相互独立
　　3, thread 的 join 方法与 isAlive 方法的区别.
　　java 代码
　　log.info("current thread running");
　　thread1.join(); // 当前线程在执行到join方法后, 会被block住 , 直到thread1线程处理结束或死亡
　　log.info("current thread stopping");
　　java 代码
　　log.info("current thread running");
　　thread1.isAlive(); // 直接返回true or false
　　log.info("current thread stopping");
　　join方法是使当前线程阻塞,直到引用的线程结束才激活.
　　4, wait-notify机制
　　在一个以上的thread wait住时,调用notify是随机的唤醒某一thread.
　　而notifyAll则是唤醒所有等待的线程, 但只有一个线程可以在唤醒后lock object monitor,
　　所以, notifyAll操作也是有利弊的.
　　wait-notify机制, 单次唤醒是随机的, 全部唤醒则会导致大部分线程阻塞.
　　8, Lock接口替代synchronized
　　a, Lock接口可以比sychronized提供更广泛的锁定操作.可以提供多把不同的锁.且锁之间互不干涉.
　　b, Lock接口提供lock()与unlock()方法, 使用明确调用来完成同步的, OO思想好于前者.
　　c, Lock可以自由操控同步范围(scope).
　　d, Lock接口支持nested lock(嵌套锁定).并提供了丰富的api.
　　e, Lock接口提供了tryLock()方法, 支持尝试取得某个object lock.
　　5, Condition替代wait与notify
　　// 生产/消费者模式
　　public class Basket {
　　　　Lock lock = new ReentrantLock();
　　　　//产生Condition对象
　　　　Condition produced = lock.newCondition();
　　　　Condition consumed = lock.newCondition();
　　　　boolean available = false;
　　　　public void produce() throws InterruptedException {
　　　　　　lock.lock();
　　　　　　try {
　　　　　　　　if (available) {
　　　　　　　　　　produced.await(); //放弃lock进入睡眠
　　　　　　　　}
　　　　　　　　System.out.println("Apple produced.");
　　　　　　　　available = true;
　　　　　　　　consumed.signal(); //发信号唤醒等待这个Condition的线程
　　　　　　} finally {
　　　　　　　　lock.unlock();
　　　　　　}
　　　　}
　　　　public void consume() throws InterruptedException {
　　　　　　lock.lock();
　　　　　　try {
　　　　　　　　if (!available) {
　　　　　　　　　　consumed.await(); //放弃lock进入睡眠
　　　　　　　　}

　　　　　　　　

会计考友 · 发表于 2012-8-4 12:37:29

　　　　　　　　System.out.println("Apple consumed.");</p>　　　　　　　　available = false;
　　　　　　　　produced.signal(); //发信号唤醒等待这个Condition的线程
　　　　　　} finally {
　　　　　　　　lock.unlock();
　　　　　　}
　　　　}
　　}
　　// 测试用类
　　public class ConditionTester {
　　　　public static void main(String[] args) throws InterruptedException {
　　　　　　final Basket basket = new Basket();
　　　　　　//定义一个producer
　　　　　　Runnable producer = new Runnable() {
　　　　　　　　　　public void run() {
　　　　　　　　　　　　try {
　　　　　　　　　　　　　　basket.produce();
　　　　　　　　　　　　} catch (InterruptedException ex) {
　　　　　　　　　　　　　　ex.printStackTrace();
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　};
　　　　　　//定义一个consumer
　　　　　　Runnable consumer = new Runnable() {
　　　　　　　　　　public void run() {
　　　　　　　　　　　　try {
　　　　　　　　　　　　　　basket.consume();
　　　　　　　　　　　　} catch (InterruptedException ex) {
　　　　　　　　　　　　　　ex.printStackTrace();
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　};
　　　　　　//各产生10个consumer和producer
　　　　　　ExecutorService service = Executors.newCachedThreadPool();
　　　　　　for (int i = 0; i < 10; i++)
　　　　　　　　service.submit(consumer);
　　　　　　Thread.sleep(2000);
　　　　　　for (int i = 0; i < 10; i++)
　　　　　　　　service.submit(producer);
　　　　　　service.shutdown();
　　　　}
　　}
　　Condition配合Lock接口可以轻松实现,比sychronized配合wait,notify更强大的功能.
　　Condition接口可以为单个对象锁生成多个类似wait-notify机制的条件变量.
　　每个条件变量在执行wait-notify时,只会控制自身条件的线程,即触发notify时,只唤醒自身条件变量上的wait线程,不会唤醒其他条件变量的wait线程.
　　建议: 同一把锁下, 允许有多个Condition, 且相互不干涉, 但是, 每个Condition都是按顺序执行的.(java关键字, 如果使用this, 则范围过大, 自己创建object来局部控制, 又不优雅)
　　注意: Condition的wait操作, 允许出现人为或意外的”虚假唤醒”, 所以, 为了保证Condition的作用域.当调用wait时, 尝试使用循环结构.其中condition为await-singal的操作标示.

　　boolean condition = true;
　　while(condition) {
　　condition.await();
　　condition = false;
　　}
　　...
　　condition = true;
　　condition.singal();

会计考友 · 发表于 2012-8-4 12:37:30

</p>　　6, 使用java.util.concurrent.atomic包,原子操作及解决volatile变量计算的race condition
　　private static AtomicInteger i = new AtomicInteger(0);
　　public void run() {
　　　　int v = i.incrementAndGet();　// 相当于++i
　　　　log.info("i = " + v);
　　}
　　包的特色:
　　1, 普通原子数值类型AtomicInteger, AtomicLong提供一些原子操作的加减运算.
　　2, 解决race condition问题的经典模式-”比对后设定”, 即查看主存中数据是否与
　　预期提供的值一致,如果一致,才更新.
　　// 这边采用无限循环
　　for (;;) {
　　　　　　　　int current = get();
　　　　　　　　if (compareAndSet(current, newValue))
　　　　　　　　　　return current;
　　}
　　3, 使用AtomicReference可以实现对所有对象的原子引用及赋值.包括Double与Float,但不包括对其的计算.浮点的计算,只能依靠同步关键字或Lock接口来实现了.
　　4, 对数组元素里的对象,符合以上特点的, 也可采用原子操作.包里提供了一些数组原子操作类建议: 针对非浮点类型的数值计算, 数组元素及对象的引用/赋值, 优先采用原子类型.
　　优先考虑使用atmoic框架 .
　　7, 利用java semaphore信号量机制,控制某操作上线程的数量
　　java信号量的实现逻辑与操作系统解决进程同步问题时采用的PV操作类似.
　　即 P -> 临界区 -> V
　　其中P为消费,V生产,临界区是同步区域.
　　java semaphore提供了acquire()与release()两种操作,类似Lock的lock()与unlock.
　　区别在于, java semaphore对acquire有数量控制,即利用它的计数器大小,来控制多少线程可执行,其余全部阻塞.
　　而Lock中的lock()方法,一次只能允许一根线程执行,其余全部阻塞.
　　semaphore接口的构造函数中还提供了一个boolean型的fair变量,表示,是否公平.
　　如果为ture,则每个线程会根据到达的顺序执行,而默认是false.
　　// 业务逻辑实现类
　　public class Logic {
　　　　private static final Log log = LogFactory.getLog(Logic.class);
　　　　private AtomicInteger sum = new AtomicInteger(0);
　　　　private Semaphore sp = new Semaphore(5); // 吞吐量为5条线程
　　　　public void test() {
　　　　　　try {
　　　　　　　　sp.acquire();
　　　　　　　　log.info(Thread.currentThread().getName() + " entered");
　　　　　　　　Thread.sleep(2000);
　　　　　　　　log.info(sum.getAndIncrement());
　　　　　　　　sp.release();
　　　　　　} catch (InterruptedException e) {
　　　　　　　　log.error("sleep error:", e);
　　　　　　}
　　　　}
　　}
　　// 线程测试类
　　public class RunThread {
　　　　public static void main(String[] args) {
　　　　　　final Logic logic = new Logic();
　　　　　　//定义一个producer
　　　　　　Runnable test = new Runnable() {
　　　　　　　　public void run() {
　　　　　　　　　　logic.test();
　　　　　　　　}
　　　　　　};
　　　　　　ExecutorService service = Executors.newCachedThreadPool();
　　　　　　for (int i = 0; i < 10; i++) {
　　　　　　　　service.submit(test);
　　　　　　}

　　　　　　service.shutdown();
　　　　}
　　}
　　注意; semaphore可以控制某个资源上读取操作的线程数量, 但是, semaphore本身是线程不安全的,
　　如果资源涉及到写入操作, 那么在操作中加上同步后, 信号量的作用也就跟Lock接口一样了.(一次只能执行一根线程)

会计考友 · 发表于 2012-8-4 12:37:31

</p>　　8, 利用CyclicBarrier屏障接口实现,线程集合/解散功能
　　java有好多种的屏障实现, 简单的几种如下:
　　a, 利用条件变量Condition实现wait-notify机制,等待所有的线程都wait在某一个
　　集合点时,notifyAll一下. 缺点是需要一根监控线程
　　b, 利用join方法,开一个监视线程, 每次调用这个线程取被block住的线程数量.
　　当达到指定数量后, 监视线程自动死亡,以放开所有的被block threads.
　　c, 利用CyclicBarrier提供的功能,只需要在集合点处调用await()方法,即可.
　　// 试验屏障功能的类
　　public class Logic {
　　　　private static final Log log = LogFactory.getLog(Logic.class);
　　　　private int value = 21;
　　　　private CyclicBarrier cyclic = new CyclicBarrier(3);
　　　　public int getValue() {
　　　　　　return value;
　　　　}
　　　　public void setValue(int value) {
　　　　　　this.value = value;
　　　　}
　　　　public void expression1() {
　　　　　　try {
　　　　　　　　Thread.sleep(1000);
　　　　　　　　log.info(value/2);
　　　　　　　　cyclic.await();
　　　　　　　　log.info(Thread.currentThread().getName() + " end.");
　　　　　　} catch (InterruptedException e) {
　　　　　　　　log.error(e);
　　　　　　} catch (BrokenBarrierException e) {
　　　　　　　　log.error(e);
　　　　　　}
　　　　}
　　　　public void expression2() {
　　　　　　try {
　　　　　　　　Thread.sleep(2000);
　　　　　　　　log.info(value*2);
　　　　　　　　cyclic.await();
　　　　　　　　log.info(Thread.currentThread().getName() + " end.");
　　　　　　} catch (InterruptedException e) {
　　　　　　　　log.error(e);
　　　　　　} catch (BrokenBarrierException e) {
　　　　　　　　log.error(e);
　　　　　　}
　　　　}
　　　　public void expression3() {
　　　　　　try {
　　　　　　　　Thread.sleep(3000);
　　　　　　　　log.info(value+2);
　　　　　　　　cyclic.await();
　　　　　　　　log.info(Thread.currentThread().getName() + " end.");
　　　　　　} catch (InterruptedException e) {
　　　　　　　　log.error(e);
　　　　　　} catch (BrokenBarrierException e) {
　　　　　　　　log.error(e);
　　　　　　}
　　　　}
　　}
　　// 线程测试类
　　public class RunThread {
　　　　public static void main(String[] args) {
　　　　　　final Logic logic = new Logic();
　　　　　　Runnable run1 = new Runnable() {
　　　　　　　　public void run() {
　　　　　　　　　　logic.expression1();
　　　　　　　　}
　　　　　　};
　　　　　　Runnable run2 = new Runnable() {
　　　　　　　　public void run() {
　　　　　　　　　　logic.expression2();
　　　　　　　　}
　　　　　　};
　　　　　　Runnable run3 = new Runnable() {
　　　　　　　　public void run() {
　　　　　　　　　　logic.expression3();
　　　　　　　　}
　　　　　　};
　　　　　　//各产生10个consumer和producer
　　　　　　ExecutorService service = Executors.newCachedThreadPool();
　　　　　　service.submit(run1);
　　　　　　service.submit(run2);
　　　　　　service.submit(run3);
　　　　　　service.shutdown();
　　　　}
　　}
　　注意: 使用屏障的时候, 小心异常的放生,当发生异常,所有线程都会被释放
　　等待中的线程将被中断. 且发生异常的屏障将不可用,需要屏障的实例reset一下.
　　9, 利用CountDownLatch接口实现线程集合/解散功能,类似CyclicBarrier,区别是倒数且只跑一次接口方法与CyclicBarrier基本相同,不同在于构造函数需要传入一数量,表示倒数的开始数量.以后会递减这个值。

		自动登录	找回密码
密码			立即注册

[基础知识] JAVA基础：java线程小结