激情福利在线,日韩一级完整毛片,日韩精品无码一区二区三区

abin — Sun, 28 Apr 2013 07:37:00 GMT

在多�U�程设计中，我猜常常会遇到线�E�间�怺��{�待以及某个�U�程�{�待1个或多个�U�程的场景，比如多线�E�精密计��和大量数据处理�Q�这里写下我自己的体会和理解�?

我想应该有很多办法，如果是简单的1�Q?关系�Q�那么可以wait�Q�）和notify�Q�）解决�Q�就像一把锁和一把钥匙；如果�?�Q�N关系�Q�这�?��需要关心N的所有状态了�Q�最�W�的办法�?可以��L��看N当前的状态，轮询询问工作是否做完。而好点的办法是N做完后主动告�?�Q?span style="color: #0000ff">然后N��׃��?�U�选择�Q�要么听�?的命令，要么�l�箋�q�自己其他的�z�R�?/span>

用传�l�的�Ҏ��我想应该是都能实现的�Q�而JDK1.5提供了CyclicBarrier与CountDownLatch来解决了�q�两个问题，而她们的区别是：

CyclicBarrier使所有线�E�相互等待，而CountDownLatch使一个或多个�U�程�{�待其他�U�程。区别类��g��面蓝色字体，CountDownLatch不会�{�待其他�U�程了，只要做完自己的工作就�q�自��q��z�d��了，也就是run()�Ҏ��里其他的��d��?/p>

Example�Q?/p>

public static void testCountDownLatch() throws InterruptedException{
  CountDownLatch cdl=new CountDownLatch(2);
  ExecutorService exe=Executors.newFixedThreadPool(2);
   class Bow implements  Runnable{
    CountDownLatch cdl;
    public Bow(CountDownLatch cdl){
    this.cdl=cdl;
    }
    public void run(){
     System.out.println("The bow is coming");
     System.out.println("kick a bow ");
     this.cdl.countDown();
     System.out.println("do other thing");
     }
   }
  exe.execute(new Bow(cdl));
  exe.execute(new Bow(cdl));
  exe.shutdown();
  System.out.println("Wait");
    cdl.await();
    System.out.println("End..");

}

    public static void main(String[] args) {
        try {
            Test.testCountDownLatch();
        } catch (InterruptedException e) {
        }
    }

输出的结果�ؓ�Q?/p>

The bow is coming
kick a bow
do other thing
Wait...
The bow is coming
kick a bow
do other thing
End..

如上所说do other thing不受影响�?/p>

写了一个CyclicBarrier的例子：

public static void testCyclicBarrier() throws InterruptedException, BrokenBarrierException{
        CyclicBarrier barr=new CyclicBarrier(2+1);

        ExecutorService exe=Executors.newFixedThreadPool(2);
         class Bow implements  Runnable{
             CyclicBarrier barr;
                public Bow(CyclicBarrier barr){
                this.barr=barr;
                }
                public void run(){
                    System.out.println("The bow is coming");
                    System.out.println("kick a down");
                    try {
                        barr.await();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("do other thing");
                    }
            }
        exe.execute(new Bow(barr));
        exe.execute(new Bow(barr));
        exe.shutdown();
        System.out.println("Wait");
        barr.await();
       System.out.println("End..");

    }

    public static void main(String[] args) {
        try {
            Test.testCyclicBarrier();
        } catch (InterruptedException e) {
        }
        catch (BrokenBarrierException e) {
        }
    }

输出�l�果为：

Wait...
The bow is coming
kick a down
The bow is coming
kick a down
do other thing
End..
do other thing

�ȝ��Q?/span>

我们看到do other thing被阻塞了�Q�直到最后才执行�Q�可见，栅栏和计数器的目完全不同了。向Doug Lea牛�h学习�Q�）

在网上看到很多�h对于CountDownLatch和CyclicBarrier的区别简单理解�ؓCountDownLatch是一�ơ性的�Q�而CyclicBarrier在调用reset之后�q�可以��l��用。那如果只是�q�么��单的话，我觉得CyclicBarrier��单命名�ؓResetableCountDownLatch好了�Q�显然不是的�?br />我的理解是，要从他们的设计目的去看这两个�c�R��javadoc里面的描�q�是�q�样的�?

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

可能是我的英语不够好吧，我感觉从�q�个javadoc里面要准��理解他们的差异�q�是不容易的�?br />我的理解�?/p>

CountDownLatch : 一个线�E?/strong>(或者多�?�Q?�{�待另外N个线�E?/strong>完成某个事情之后才能执行�? CyclicBarrier : N个线�E?/strong>�怺��{�待�Q��Q何一个线�E�完成之前，所有的�U�程都必��ȝ��待�?br />�q�样应该��清楚一点了�Q�对于CountDownLatch来说�Q�重�Ҏ��那个“一个线�E?#8221;, 是它在等待，而另外那N的线�E�在�?strong>“某个事情”做完之后可以�l�箋�{�待�Q�可以终止。而对于CyclicBarrier来说�Q�重�Ҏ��?strong>N个线�E?/strong>�Q�他们之间�Q何一个没有完成，所有的�U�程都必��ȝ��待�?/p>

CountDownLatch 是计数器, �U�程完成一个就��C��? ��像报数一�? 只不�q�是递减�?
而CyclicBarrier更像一个水�? �U�程执行��想水流, 在水闸处都会堵住, �{�到水满(�U�程到齐)�? 才开始泄��?

abin 2013-04-28 15:37 发表评论

Object之wait,notify,notifyAll

abin — Wed, 16 Jan 2013 15:46:00 GMT
Java所有的�c�都��h��U�程的潜力，Java赋予的每个对象一个锁�Q�在计算机内部工作在同一旉��Q�只有一个对象可以持有锁�Q�也��是说程序在同一旉��只有一个程序可以运行，�q�里我把对象比作是一个小的程序。而多处理器，那么��另当别��Z��?
      在这里我们首先学习一下公共方法wait,notify,notifyAll�?/p>
      wait�Ҏ��可以使在当前�U�程的对象等待，直到别的�U�程调用此对象的notify或notifyAll�Ҏ��Q�注意：调用的是此对象的notify和notifyAll�Q�，�q�且当前�q�行的线�E�必��d��有此对象的对象监视器

package com.abin.lee.thread.thread;

public class CarryTask extends Thread {
public void run() {
        try {
            synchronized (this) {
                Thread t = Thread.currentThread();
                System.out.println(t.getId() + t.getName() + ":task start, wait for notify...");
                this.wait();
                System.out.println(t.getId() + t.getName() + ":task continue...");
            }
        } catch (InterruptedException ex) {
           System.out.println(CarryTask.class.getName());
        }
    }

}

package com.abin.lee.thread.thread;

public class CarryWait {
public static void main(String[] args) throws InterruptedException {
  CarryTask task = new CarryTask();
  Thread t = Thread.currentThread();
  System.out.println(t.getId() + t.getName() + ":task start...");
  task.start();
  Thread.sleep(2000);
  synchronized (task) {
   System.out.println("id="+Thread.currentThread().getId()+",Name="+Thread.currentThread().getName()+",task="+task+",notify");
   task.notify();
  }
}

}

http://www.iteye.com/topic/1124814

abin 2013-01-16 23:46 发表评论

Future FutureTask

abin — Thu, 10 Jan 2013 06:17:00 GMT

//实例一�Q�这里面用到了信号量Semaphore和FutureTask

package net.abin.lee.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class FutureGo implements Callable {
private String message;
private static final Semaphore semaphore=new Semaphore(3);
private final ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
public FutureGo(String message) {
  this.message = message;
}

public String call() throws InterruptedException {
  semaphore.acquire();
  Lock read=rwl.readLock();
  Lock write=rwl.readLock();
  read.lock();
  System.out.println("message"+message+",Name"+Thread.currentThread().getName()+"�q�来�?);
  read.unlock();
  write.lock();
  String result=message+"你好!";
  Thread.sleep(1000);
  System.out.println("message"+message+"Name"+Thread.currentThread().getName()+"��d��?);
  write.unlock();
  semaphore.release();
  return result;
}
}

//FutureTaskTest.java

package net.abin.lee.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {
public static void main(String[] args) throws InterruptedException,
   ExecutionException {
  Callable go = new FutureGo("abin");
  FutureTask task = new FutureTask(go);
  ExecutorService executor = Executors.newCachedThreadPool();
  if (!executor.isShutdown()) {
   executor.execute(task);
  }
  String result = "";
  if (!task.isDone()) {
   result = (String) task.get();
   System.out.println("result=" + result);
  }
   executor.shutdown();
}

}

//实例一�Q�这里面用到了信号量Semaphore和FutureTask

abin 2013-01-10 14:17 发表评论

java�U�程�q�发库学�?-CyclicBarrier

abin — Mon, 07 Jan 2013 16:39:00 GMT

public class CyclicBarrier
extends Object
一个同步辅助类�Q�它允许一�l�线�E�互相等待，直到到达某个公共屏障�?nbsp;(common barrier point)。在涉及一�l�固定大��的�U�程的程序中�Q�这些线�E�必��M��时地互相�{�待�Q�此�?nbsp;CyclicBarrier 很有用。因�� barrier 在释攄��待线�E�后可以重用�Q�所以称它�ؓ循环 �?nbsp;barrier�?br />CyclicBarrier 支持一个可选的 Runnable 命��o�Q�在一�l�线�E�中的最后一个线�E�到达之后（但在释放所有线�E�之前）�Q�该命��o只在每个屏障点运行一�ơ。若在��l�所有参与线�E�之前更新共享状态，此屏障操�?nbsp;很有用�?br />以上是jdk文档的说�?br />
     *  现在说说我们今天�z�d��的内宏V��首先我们要在公司大厅集合、然后参观陈云故�?br />     *  参观完后集合、准备去淀水湖参观。（�?辆�R、对�?个线�E�）
     *
     *  我们必须�{�大安��到齐了才能去下个地方、比如说、在公司集合�?辆�R子都��C��才能出发
     *  要不然�h装不下啊。这是我们可以用到java�U�程�q�发库的CyclicBarrier�c?br />
public class CyclicBarrierTest {

    public static void main(String[] args) {

        final CyclicBarrier cb = new CyclicBarrier(3);
        //final Semaphore semaphore=new Semaphore(1);

        for (int i = 1; i <= 3; i++) {

            new Thread(new Runnable() {

                @Override
                public void run() {
                    try {

                        //semaphore.acquire();
                        System.out.println(Thread.currentThread().getName()
                                + "公司大厅集合");
                        System.out.println(Thread.currentThread().getName()
                                + "公司大厅�{�待....");
                        //semaphore.release();
                        cb.await();
                        Thread.sleep(2000);


                        //semaphore.acquire();
                        System.out.println(Thread.currentThread().getName()
                                + "陈云故居集合");
                        System.out.println(Thread.currentThread().getName()
                                + "陈云故居�{�待....");
                        //semaphore.release();
                        cb.await();
                        Thread.sleep(2000);


                        //semaphore.acquire();
                        System.out.println(Thread.currentThread().getName()
                                + "淀水湖集合");
                        System.out.println(Thread.currentThread().getName()
                                + "淀水湖�{�待....准备回家�?);
                        //semaphore.release();
                        cb.await();
                        Thread.sleep(2000);


                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }

            }).start();
        }
    }
}
以下是输出结果：
Thread-0公司大厅集合
Thread-0公司大厅�{�待....
Thread-2公司大厅集合
Thread-1公司大厅集合
Thread-1公司大厅�{�待....
Thread-2公司大厅�{�待....
Thread-0陈云故居集合
Thread-1陈云故居集合
Thread-2陈云故居集合
Thread-1陈云故居�{�待....
Thread-0陈云故居�{�待....
Thread-2陈云故居�{�待....
Thread-0淀水湖集合
Thread-2淀水湖集合
Thread-1淀水湖集合
Thread-2淀水湖�{�待....准备回家�?br />Thread-0淀水湖�{�待....准备回家�?br />Thread-1淀水湖�{�待....准备回家�?br />
***注意上述代码中的Semaphore�c�R��它也是java�U�程�q�发库中的一个类、更多具体作用我们以后再探讨�?br />以下是��用Semaphore后的输出�l�果�Q�（�怿�你已�l�知道不同的地方了）
Thread-0公司大厅集合
Thread-0公司大厅�{�待....
Thread-1公司大厅集合
Thread-1公司大厅�{�待....
Thread-2公司大厅集合
Thread-2公司大厅�{�待....
Thread-2陈云故居集合
Thread-2陈云故居�{�待....
Thread-1陈云故居集合
Thread-1陈云故居�{�待....
Thread-0陈云故居集合
Thread-0陈云故居�{�待....
Thread-2淀水湖集合
Thread-2淀水湖�{�待....准备回家�?br />Thread-1淀水湖集合
Thread-1淀水湖�{�待....准备回家�?br />Thread-0淀水湖集合
Thread-0淀水湖�{�待....准备回家�?br />
http://blog.sina.com.cn/s/blog_7f448c520101219g.html

abin 2013-01-08 00:39 发表评论

java�U�程�q�发库学�?-Exchanger

abin — Mon, 07 Jan 2013 16:35:00 GMT

public class Exchanger
extends Object
可以在对中对元素�q�行配对和交换的�U�程的同步点。每个线�E�将条目上的某个�Ҏ��呈现�l?nbsp;exchange �Ҏ��Q�与伙伴�U�程�q�行匚w��Q��ƈ且在�q�回时接收其伙伴的对象。Exchanger 可能被视�?nbsp;SynchronousQueue 的双向�Ş式。Exchanger 可能在应用程序（比如遗传��法和管道设计）中很有用�?br />
以上是jdk文档的说明�?br />
  * 今天公司党委�l�织�z�d��?2点半call我电话、我�?0码的速度狂奔�q�去、上了一个�R子（A车）�?br />  * 戴着眼镜四处瞄了下，没发��C��么美奛_��。假寐了一会儿�Q�司��另外一个�R子（B车）上要换过�?br />  * 一个�h、让车子上的��Z��M��个去B车。由于地势原因、我��׃��M��?br />  *
  * 一路上�H�然惛_��了java�U�程�q�发库中的Exchanger�c�R��A车我们可以看作是一个线�E�、B车我们也可以
  * 看作是一个线�E�，我和B车上的一位美��x��位子�Q�就可以用到Exchanger�cȝ��exchange�Ҏ��?br />  *
  * 代码如下�Q?br />
public class ExchangerTest {

    public static void main(String[] args) {

        final Exchanger exchange=new Exchanger();
        //final String a="yupan";
        //final String b="a girl";
        final String[] carA=new String[]{"zhangsan","lisi","yupan"};
        final String[] carB=new String[]{"meinv_a","meinv_b","meinv_c"};

        //A车线�E?br />        new Thread(new Runnable(){

            String[] carA_copy=carA;
            @Override
            public void run() {
                try {
                    System.out.println("交换前：A车上的第三位乘客�Q?+carA[2]);
                    carA_copy[2]=exchange.exchange(carA_copy[2]);
                    System.out.println("交换后：A车上的第三位乘客�Q?+carA[2]);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }).start();

        //B车线�E?br />        new Thread(new Runnable(){

            String[] carB_copy=carB;
            @Override
            public void run() {
                try {
                    System.out.println("交换前：B车上的第三位乘客�Q?+carB[2]);
                    carB_copy[2]=exchange.exchange(carB_copy[2]);
                    System.out.println("交换后：B车上的第三位乘客�Q?+carB[2]);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }).start();

    }
}

输出�l�果�Q?br />
交换前：A车上的第三位乘客�Q�yupan
交换前：B车上的第三位乘客�Q�meinv_c
交换后：B车上的第三位乘客�Q�yupan
交换后：A车上的第三位乘客�Q�meinv_c

http://blog.sina.com.cn/s/blog_7f448c5201012183.html

abin 2013-01-08 00:35 发表评论

Java 信号�?Semaphore 介绍

abin — Mon, 07 Jan 2013 16:11:00 GMT
Semaphore当前在多�U�程环境下被扩放使用�Q?/span>操作�pȝ��的信号量是个很重要的概念�Q�在�q�程控制斚w��都有应用。Java �q�发�?的Semaphore 可以很轻村֮�成信号量控制�Q�Semaphore可以控制某个资源可被同时讉K��的个敎ͼ�通过 acquire() 获取一个许可，如果没有��q��待，�?release() 释放一个许可。比如在Windows下可以设�|�共享文件的最大客��L��讉K��个数�?nbsp;
Semaphore实现的功能就�c�M��厕所�?个坑�Q�假如有10个�h要上厕所�Q�那么同时只能有多少个�h��M��厕所呢？同时只能�?个�h能够占用�Q�当5个�h�?的�Q何一个�h让开后，其中�{�待的另�?个�h中又有一个�h可以占用了。另外等待的5个�h中可以是随机获得优先��Z��Q�也可以是按照先来后到的��序获得��Z��Q�这取决于构造Semaphore对象时传入的参数选项。单个信号量的Semaphore对象可以实现互斥锁的功能�Q��ƈ且可以是�׃��个线�E�获得了“�?#8221;�Q�再由另一个线�E�释�?#8220;�?#8221;�Q�这可应用于死锁恢复的一些场合�?br />
Semaphore�l�护了当前访问的个数�Q�提供同步机�Ӟ��控制同时讉K��的个数。在数据�l�构中链表可以保�?#8220;无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能�Q�但实现上要复杂些�?nbsp;

下面的Demo中申明了一个只�?个许可的Semaphore�Q�而有20个线�E�要讉K��q�个资源�Q�通过acquire()和release()获取和释放访问许可�?/p>
package com.test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Semaphore;

public class TestSemaphore {

public static void main(String[] args) {

  // �U�程�?/span>

ExecutorService exec = Executors.newCachedThreadPool();

  // 只能5个线�E�同时访�?/span>

final Semaphore semp = new Semaphore(5);

// 模拟20个客��L��讉K��

for (int index = 0; index < 20; index++) {

final int NO = index;

  Runnable run = new Runnable() {

public void run() {

  try {

  // 获取许可

semp.acquire();

  System.out.println("Accessing: " + NO);

Thread.sleep((long) (Math.random() * 10000));

  // 讉K��完后�Q�释�?/span>

semp.release();

  System.out.println("-----------------"+semp.availablePermits());

} catch (InterruptedException e) {

e.printStackTrace();

  }

  }

  };

exec.execute(run);

   }

// 退出线�E�池

exec.shutdown();

}

}

执行�l�果如下�Q?/span>

Accessing: 0

Accessing: 1

Accessing: 3

Accessing: 4

Accessing: 2

-----------------0

Accessing: 6

-----------------1

Accessing: 7

-----------------1

Accessing: 8

-----------------1

Accessing: 10

-----------------1

Accessing: 9

-----------------1

Accessing: 5

-----------------1

Accessing: 12

-----------------1

Accessing: 11

-----------------1

Accessing: 13

-----------------1

Accessing: 14

-----------------1

Accessing: 15

-----------------1

Accessing: 16

-----------------1

Accessing: 17

-----------------1

Accessing: 18

-----------------1

Accessing: 19

http://www.cnblogs.com/whgw/archive/2011/09/29/2195555.html

abin 2013-01-08 00:11 发表评论

Java�q�发包中的几�U�ExecutorService

abin — Wed, 19 Dec 2012 04:39:00 GMT

1.CachedThreadPool

CachedThreadPool首先会按照需要创��够多的线�E�来执行��d��(Task)。随着�E�序执行的过�E�，有的�U�程执行完了��d��Q�可以被重新循环使用�Ӟ��才不再创建新的线�E�来执行��d��。我们采用《Thinking In Java》中的例子来分析�?/p>
首先�Q��Q务定义如�?实现了Runnable接口�Q��ƈ且复写了run�Ҏ��)�Q?/p>
package net.jerryblog.concurrent;
public class LiftOff implements Runnable{
    protected int countDown = 10; //Default
    private static int taskCount = 0;
    private final int id = taskCount++;
    public LiftOff() {}
    public LiftOff(int countDown) {
        this.countDown = countDown;
    }
    public String status() {
        return "#" + id + "(" +
            (countDown > 0 ? countDown : "LiftOff!") + ") ";
    }
    @Override
    public void run() {
        while(countDown-- > 0) {
            System.out.print(status());
            Thread.yield();
        }

    }
}

采用CachedThreadPool方式执行�~�写的客��L��E�序如下�Q?nbsp;

package net.jerryblog.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPool {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i = 0; i < 10; i++) {
            exec.execute(new LiftOff());
        }
        exec.shutdown();
    }
}

上面的程序中�Q�有10个�Q务，采用CachedThreadPool模式�Q�exec没遇��C��个LiftOff的对�?Task)�Q�就会创��Z��个线�E�来处理��d��。现在假��N��到到�W?个�Q务时�Q�之前用于处理第一个�Q务的�U�程已经执行完成��d��了，那么不会创徏新的�U�程来处理�Q务，而是使用之前处理�W�一个�Q务的�U�程来处理这�W?个�Q务。接着如果遇到�W?个�Q务时�Q�前面那些�Q务都�q�没有执行完�Q�那么就会又新创建线�E�来执行�W?个�Q务。否则，使用之前执行完�Q务的�U�程来处理新的�Q务�?
2.FixedThreadPool

   FixedThreadPool模式会��用一个优先固定数目的�U�程来处理若�q�数目的��d��。规定数目的�U�程处理所有�Q务，一旦有�U�程处理完了��d��׃��被用来处理新的�Q�?如果有的�?。这�U�模式与上面的CachedThreadPool是不同的�Q�CachedThreadPool模式下处理一定数量的��d��的线�E�数目是不确定的。而FixedThreadPool模式�?span style="color: #ff0000">最�?/span> 的线�E�数目是一定的�?/p>
采用FixedThreadPool模式�~�写客户端程序如下：

package net.jerryblog.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPool {
    public static void main(String[] args) {
        //三个�U�程来执行五个�Q�?
        ExecutorService exec = Executors.newFixedThreadPool(3);
        for(int i = 0; i < 5; i++) {
            exec.execute(new LiftOff());
        }
        exec.shutdown();
    }
}

3.SingleThreadExecutor模式

SingleThreadExecutor模式只会创徏一个线�E�。它和FixedThreadPool比较�c�M��Q�不�q�线�E�数是一个。如果多个�Q务被提交�l�SingleThreadExecutor的话�Q�那么这些�Q务会被保存在一个队列中�Q��ƈ且会按照��d��提交的顺序，一个先执行完成再执行另外一个线�E��?/p>
SingleThreadExecutor模式可以保证只有一个�Q务会被执行。这�U�特点可以被用来处理�׃�n资源的问题而不需要考虑同步的问题�?/p>
SingleThreadExecutor模式�~�写的客��L��E�序如下�Q?nbsp;

package net.jerryblog.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 2; i++) {
            exec.execute(new LiftOff());
        }
    }
}

�q�种模式下执行的�l�果如下�Q?br />#0(9) #0(8) #0(7) #0(6) #0(5) #0(4) #0(3) #0(2) #0(1) #0(LiftOff!)
#1(9) #1(8) #1(7) #1(6) #1(5) #1(4) #1(3) #1(2) #1(1) #1(LiftOff!)
�W�一个�Q务执行完了之后才开始执行第二个��d��?span style="font-size: 12px">

abin 2012-12-19 12:39 发表评论

java多线�E?�q�回�l�果

abin — Fri, 07 Dec 2012 02:36:00 GMT
�Ҏ��一�Q?br />
package com.abin.lee.thread;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class ThreadSync{

public static List ThreadSync(final String message) throws InterruptedException{
  final List list=new LinkedList();
  Thread thread=new Thread(){
   public void run(){
    if(message.equals("one")){
     list.add(0, message);
    }
   }
  };
  thread.start();
  thread.join();
  return list;
}

public static void main(String[] args) throws InterruptedException {
  List list=ThreadSync("one1");
  System.out.println("size="+list.size());
  for(Iterator it=list.iterator();it.hasNext();){
   Object obj=(Object)it.next();
   System.out.println("obj="+obj);
  }

}
}

�Ҏ��二：

abin 2012-12-07 10:36 发表评论

如何快速处理十万条数据到数据库

abin — Tue, 04 Dec 2012 16:54:00 GMT

如何快速处理十万条数据到数据库

abin 2012-12-05 00:54 发表评论

abin — Fri, 16 Nov 2012 17:38:00 GMT

public class Example{
    public static void main(String args[]){
        A target=new A();    //�U�程thread的目标对�?nbsp;
        Thread thread=new Thread(target);
        thread.setName("张三");
        thread.start();
        while(target.getStop()==false){}
        System.out.println("我是�ȝ��E?负责恢复"+thread.getName()+"�U�程");
        target.restart();  //恢复thread�U�程
    }
}
class A implements Runnable{
    int number=0;
    boolean stop=false;
    boolean getStop(){
            return stop;
    }
    public void run(){
        while(true){
            number++;
            System.out.println(Thread.currentThread().getName()+"的number="+number);
            if(number==3){
                try{  System.out.println(Thread.currentThread().getName()+"被挂�?);
                     stop=true;
                     hangUP();//挂�v�U�程
                     System.out.println(Thread.currentThread().getName()+"恢复执行");
                }
                catch(Exception e){}
            }
            try{ Thread.sleep(1000);
            }
           catch(Exception e){}
        }
    }
    public synchronized void  hangUP() throws InterruptedException{
        wait();
    }
    public synchronized void  restart(){
        notifyAll();
    }
}

求教�Q�main�Ҏ��中的�I��@环是做什么用的？初学�U�程�Q�不是很理解�?/span>
while(target.getStop()==false){}
�{�待target�U�程�l�束�Q�target�U�程�q�行在主�U�程main里面�Q�如果没有这个空循环�Q�主�U�程��序执行�Q�target�q�没有执行完得时候主�U�程已经执行完退��Z��Q�会��D��target也退出�?/span>

abin 2012-11-17 01:38 发表评论

java wait()与notify()

abin — Fri, 16 Nov 2012 17:01:00 GMT
下面的例子通过wait()来取代忙�{�待机制�Q�当收到通知消息�Ӟ��notify当前Monitor�cȝ��E��?/span>
package com.abin.lee.servlet.mythread.runnable;
import java.util.concurrent.TimeUnit;
public class MyObject implements Runnable{
private Monitor monitor;
public MyObject(Monitor monitor) {
this.monitor=monitor;
}
public void run(){
try {
System.out.println("beforeTimeUnit.SECONDS="+System.currentTimeMillis());
TimeUnit.SECONDS.sleep(3);
System.out.println("i am going");
monitor.getMessage();
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}

package com.abin.lee.servlet.mythread.runnable;
public class Monitor implements Runnable{
private volatile boolean go=false;
public synchronized void getMessage(){
System.out.println("beforenotify getMessage="+System.currentTimeMillis());
go=true;
notify();
System.out.println("afternotify getMessage="+System.currentTimeMillis());
}
public synchronized void watching() throws InterruptedException{
System.out.println("beforewait watching="+System.currentTimeMillis());
while(go==false)
wait();
System.out.println("he has gone");
}
public void run(){
try {
watching();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

package com.abin.lee.servlet.mythread.runnable;
public class Wait {
public static void main(String[] args) {
Monitor monitor=new Monitor();
MyObject obj=new MyObject(monitor);
new Thread(obj).start();
new Thread(monitor).start();
}
}

abin 2012-11-17 01:01 发表评论

abin — Fri, 16 Nov 2012 13:43:00 GMT
Java中是不是父线�E�阻塞后子线�E�就无法�l�箋执行�Q?/span>
如果不是�Q�该如何实现��d��父线�E�但�l�箋执行子线�E�？
不是�Q�这个问题属于线�E�调度�?br />让一个线�E�明��的�l�另外一个线�E�运行机会，采用以下�Ҏ��Q?br />1.调整�U�程优先�U?br />2.让处于运行状态的�U�程调用Thread.sleep�Q�）�Ҏ��
3.让处于运行状态的�U�程调用Thread.yield�Q�）�Ҏ��
4.让处于运行状态的�U�程调用另外一个线�E�的jion�Q�）�Ҏ��

abin 2012-11-16 21:43 发表评论

多线�E�题�?

abin — Fri, 09 Nov 2012 13:37:00 GMT

看到一个题目：针对下面的程序，写出magic�Ҏ�� 让整个程序只打印出step1,step2 不打印step3

    public static void enter(Object obj) {
        System.out.println("Step 1");
        try {
   magic1(obj);
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
        System.out.println("Step 2");
        synchronized (obj) {
            System.out.println("Step 3 (never reached here)");
        }
    }
题目的意思很�Ҏ��理解�Q�可是要做出�q�道题目需要对多线�E�的基本改进非常的理解�?/p>
下面列出基本思�\�Q?/p>

�ȝ��E�想获取obj的锁�Q�但是获取不刎ͼ�说明子线�E�始�l�在占据着�q�个对象的锁�?/p>
同时�ȝ��E�又能返回�?/p>
那现在就要实现让子线�E�先跑，然后再唤醒主�U�程。这个显然是锁的占有和唤醒，那么问题来了�Q�将什么做��个锁呢？如果�?span style="font-size: 10pt">obj的话�Q�不可能�Q�因为子�U�程昄��不能在放�?span style="font-size: 10pt">obj.

那么只能是子�U�程自己的锁�?/p>

下边是程�?/p>    static void magic1(final Object obj) throws Exception{
    final Thread t = new Thread(){
      public void run(){
       synchronized(this){
        synchronized(obj){
         try {
          notify();
       join();
      } catch (InterruptedException e) {
      }
        }

       }

      }
    };
    synchronized(t){
      t.start();
      t.wait();
    }
    }

abin 2012-11-09 21:37 发表评论

Java 多线�E?加到100

abin — Mon, 05 Nov 2012 14:40:00 GMT

package com.abin.lee.servlet.mythread.runnable;

import java.util.concurrent.atomic.AtomicInteger;

public class SumThread implements Runnable{
private AtomicInteger num=new AtomicInteger(0);
public void run(){
  while(num.get()<100){
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   if(num.get()==40){
    Thread thread2=new Thread(this,"thread2");
    thread2.start();
   }
   System.out.println(Thread.currentThread().getName()+":"+num.getAndIncrement());
  }
}

}

package com.abin.lee.servlet.mythread.runnable;

public class SumThreadTest {
public static void main(String[] args) {
  SumThread ru=new SumThread();
  Thread thread1=new Thread(ru,"thread1");
  thread1.start();
}
}

abin 2012-11-05 22:40 发表评论

Java volatile(一)

abin — Thu, 18 Oct 2012 02:38:00 GMT

Volatile修饰的成员变量在每次被线�E�访问时�Q�都��从共享内存中重读该成员变量的倹{��而且�Q�当成员变量发生变化�Ӟ��U�程��变化值回写到�׃�n内存。这样在��M��时刻�Q?/pre>
两个不同的线�E��L��看到某个成员变量的同一个倹{�? Java语言规范中指出：��Z��获得最佳速度�Q�允许线�E�保存共享成员变量的�U�有拯��Q�而且只当�U�程�q�入或者离开同步代码块时才与�׃�n成员变量的原始值对比�? �q�样当多个线�E�同时与某个对象交互�Ӟ��必��要注意到要让线�E�及时的得到�׃�n成员变量的变化�? 而volatile关键字就是提�C�VM�Q�对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互�? 使用��Q�在两个或者更多的�U�程讉K��的成员变量上使用volatile。当要访问的变量已在synchronized代码块中�Q�或者�ؓ帔R��Ӟ��不必使用�? �׃��使用volatile屏蔽掉了VM中必要的代码优化�Q�所以在效率上比较低�Q�因此一定在必要时才使用此关键字�? ��p��C中的一�?��止�~�译器进行优化~~~~
在�ƈ发中可保证内存一致�?br />volatile声明的变量只在主存中存储
��d��的时候，会有��d��脏数据的情况发生
但是写数据的时候，是能保证数据能正��写�?br />
volatile只保证每�ơ都从主存拿数据�Q�其他保证不了什么吧�Q?br />告诉�~�译器不要��用缓�?br />
非long、double变量不能保证原子性，非volatile变量不能保证内存可见性�?br />
volatile �q�能防止reorder...
��是内存屏蔽�Q�防止指令重�?br />其实目的��是保证可见�?br />可以操作volatile...变量但是不代表你的操作指令是原子�?br />

abin 2012-10-18 10:38 发表评论

java中volatile关键字的含义

abin — Thu, 18 Oct 2012 02:38:00 GMT

在java�U�程�q�发处理中，有一个关键字volatile的��用目前存在很大的��h��Q�以��Z��用这个关键字�Q�在�q�行多线�E��ƈ发处理的时候就可以万事大吉�?/p>
Java语言是支持多�U�程的，��Z��解决�U�程�q�发的问题，在语�a�内部引入�?同步�?�?volatile 关键字机制�?/p>

synchronized

同步块大安��比较熟悉�Q�通过 synchronized 关键字来实现�Q�所有加上synchronized �?块语句，在多�U�程讉K��的时候，同一时刻只能有一个线�E�能够用

synchronized 修饰的方�?或�?代码块�?/p>

volatile

用volatile修饰的变量，�U�程在每�ơ��用变量的时候，都会��d��变量修改后的最的倹{��volatile很容易被误用�Q�用来进行原子性操作�?/p>

下面看一个例子，我们实现一个计数器�Q�每�ơ线�E�启动的时候，会调用计数器inc�Ҏ��Q�对计数器进行加一

执行环境——jdk版本�Q�jdk1.6.0_31 �Q�内�?�Q?G   cpu�Q�x86 2.4G

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

public class Counter {



    public static int count = 0;



    public static void inc() {



        //�q�里延迟1毫秒�Q��得结果明�?

        try {

            Thread.sleep(1);

        } catch (InterruptedException e) {

        }



        count++;

    }



    public static void main(String[] args) {



        //同时启动1000个线�E�，去进行i++计算�Q�看看实际结�?



        for (int i = 0; i < 1000; i++) {

            new Thread(new Runnable() {

                @Override

                public void run() {

                    Counter.inc();

                }

            }).start();

        }



        //�q�里每次�q�行的值都有可能不�?可能�?000

        System.out.println("�q�行�l�果:Counter.count=" + Counter.count);

    }

}

?

1



?

1

�q�行�l�果:Counter.count=995

?

1

实际�q�算�l�果每次可能都不一��P��本机的结果�ؓ�Q�运行结�?Counter.count=995�Q�可以看出，在多�U�程的环境下�Q�Counter.count�q�没有期望结果是1000

?

1



?

1

很多��Z��为，�q�个是多�U�程�q�发问题�Q�只需要在变量count之前加上volatile��可以避免这个问题，那我们在修改代码看看�Q�看看结果是不是�W�合我们的期�?/code>

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

public class Counter {



    public volatile static int count = 0;



    public static void inc() {



        //�q�里延迟1毫秒�Q��得结果明�?

        try {

            Thread.sleep(1);

        } catch (InterruptedException e) {

        }



        count++;

    }



    public static void main(String[] args) {



        //同时启动1000个线�E�，去进行i++计算�Q�看看实际结�?



        for (int i = 0; i < 1000; i++) {

            new Thread(new Runnable() {

                @Override

                public void run() {

                    Counter.inc();

                }

            }).start();

        }



        //�q�里每次�q�行的值都有可能不�?可能�?000

        System.out.println("�q�行�l�果:Counter.count=" + Counter.count);

    }

}

�q�行�l�果:Counter.count=992

�q�行�l�果�q�是没有我们期望�?000�Q�下面我们分析一下原�?/p>

�?java 垃圾回收整理一文中�Q�描�q�C��jvm�q�行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈�Q�每一个线�E�运行时都有一个线�E�栈�Q?/p>
�U�程栈保存了�U�程�q�行时候变量��g��息。当�U�程讉K��某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的��|��然后把堆内存

变量的具体值load到线�E�本地内存中�Q�徏立一个变量副本，之后�U�程��׃��再和对象在堆内存变量值有��M��关系�Q�而是直接修改副本变量的��|��

在修改完之后的某一个时刻（�U�程退��Z��前）�Q�自动把�U�程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一�q�图

描述�q�写交互

read and load 从主存复制变量到当前工作内存
use and assign 执行代码�Q�改变共享变量�?
store and write 用工作内存数据刷��C��存相兛_��?/p>
其中use and assign 可以多次出现

但是�q�一些操作�ƈ不是原子性，也就�?在read load之后�Q�如果主内存count变量发生修改之后�Q�线�E�工作内存中的值由于已�l�加载，不会产生对应的变化，所以计��出来的�l�果会和预期不一�?/p>
对于volatile修饰的变量，jvm虚拟机只是保证从��d��存加载到�U�程工作内存的值是最新的

例如假如�U�程1�Q�线�E? 在进行read,load 操作中，发现��d��存中count的值都�?�Q�那么都会加载这个最新的�?/p>
在线�E?堆count�q�行修改之后�Q�会write��C��内存中，��d��存中的count变量��׃��变�ؓ6

�U�程2�׃��已经�q�行read,load操作�Q�在�q�行�q�算之后�Q�也会更��C��内存count的变量��gؓ6

��D��两个�U�程及时用volatile关键字修改之后，�q�是会存在�ƈ发的情况�?/p>

爱公司的�E�序�?/a>
博客园blog地址:http://www.cnblogs.com/aigongsi/
本�h版权归作者和博客园所有，�Ƣ迎转蝲�Q��{载请注明出处�?

abin 2012-10-18 10:38 发表评论

abin — Fri, 12 Oct 2012 15:41:00 GMT
�W�一�U�：�Q�Thread�Q?/span>

package com.abin.lee.servlet.mythread.thread;

public class Mythread extends Thread{
private String name;
public Mythread(String name) {
  this.name=name;
}
public void run() {
  synchronized(this.name){
   System.out.println("开始时��_��"+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());
   System.out.println("name="+name);
   System.out.println("�l�束旉��Q?+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());

  }
}

}

��试代码�Q?/span>

package com.abin.lee.servlet.mythread.thread;

public class MythreadTest {
public static void main(String[] args) {
  Mythread mythread1=new Mythread("ManyThread");
  Mythread mythread2=new Mythread("ManyThread");
  mythread1.start();
  mythread2.start();
}

}

�W�二�U�：�Q�Runnable�Q?/span>

package com.abin.lee.servlet.mythread.runnable;

public class MyRunnable implements Runnable{
private String name;
public MyRunnable(String name) {
  this.name=name;
}
public synchronized void run(){
   System.out.println("开始时��_��"+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());
   System.out.println("name="+name);
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("�l�束旉��Q?+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());
}
}

��试代码�Q?/span>

package com.abin.lee.servlet.mythread.runnable;

public class MyRunnableTest {
public static void main(String[] args) {
  MyRunnable myRunnable=new MyRunnable("ManyThread");
  Thread thread1=new Thread(myRunnable);
  Thread thread2=new Thread(myRunnable);
  thread1.start();
  thread2.start();
}
}

�W�三�U�：�Q�Callable�Q�这�U�说明一下，�q�个实现多线�E�的方式是在JDK1.5引进的，在java.util.concurrent.Callable �q�个�q�发包下面，�q�且提供同步�q�回�l�果的多�U�程�?/span>

package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyCallable implements Callable{
private String name;
public MyCallable(String name) {
  this.name=name;
}
public String call() throws Exception {
  Lock lock=new ReentrantLock();
  lock.lock();
  String result="";
  try {
   System.out.println("开始时��_��"+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());
   System.out.println("name="+name);
   if(name.equals("ManyThread")){
    result="success";
   }else{
    result="failure";
   }
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("�l�束旉��Q?+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());

  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   lock.unlock();
  }
     return result;
}

}

��试代码�Q?/span>

package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.junit.Test;

public class MyCallableTest {
@Test
public void testMyCallable() throws InterruptedException, ExecutionException{
  ExecutorService executor=Executors.newFixedThreadPool(3);
  MyCallable myCallable=new MyCallable("ManyThread");
  Future future1=executor.submit(myCallable);
  System.out.println("future1="+future1.get());
  Future future2=executor.submit(myCallable);
  System.out.println("future2="+future2.get());
  Future future3=executor.submit(myCallable);
  System.out.println("future3="+future3.get());

}

}

��试�l�果�Q?br />

开始时��_��1350056647659,�U�程名字�Q�pool-1-thread-1

name=ManyThread

�l�束旉��Q?350056650661,�U�程名字�Q�pool-1-thread-1

future1=success

开始时��_��1350056650661,�U�程名字�Q�pool-1-thread-2

name=ManyThread

�l�束旉��Q?350056653661,�U�程名字�Q�pool-1-thread-2

future2=success

开始时��_��1350056653662,�U�程名字�Q�pool-1-thread-3

name=ManyThread

�l�束旉��Q?350056656663,�U�程名字�Q�pool-1-thread-3

future3=success

abin 2012-10-12 23:41 发表评论

Java ThreadLocal

abin — Sat, 01 Sep 2012 09:03:00 GMT

//ThreadLocal�W�一�U�用法：

//��Q?br />
-- Create table
create table USERBEAN
(
ID NVARCHAR2(40) not null,
USERNAME NVARCHAR2(40),
PASSWORD NVARCHAR2(40)
)
tablespace USERS
pctfree 10
initrans 1
maxtrans 255
storage
(
initial 64K
minextents 1
maxextents unlimited
);
-- Create/Recreate primary, unique and foreign key constraints
alter table USERBEAN
add constraint SSSID primary key (ID)
using index
tablespace USERS
pctfree 10
initrans 2
maxtrans 255
storage
(
initial 64K
minextents 1
maxextents unlimited
);

package com.abin.lee.collection.threadlocal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class MyThreadLocal {
//使用ThreadLocal保存Connection变量
public static ThreadLocal threadLocal = new ThreadLocal();
private static final String URL = "jdbc:oracle:thin:@localhost:1521:XE";
private static final String USERNAME = "abing";
private static final String PWD = "abing";
public static Connection getConnection() {
Connection connection = null;
String url = "";
//如果connThreadLocal没有本线�E�对应的Connection创徏一个新的Connection�Q��ƈ��其保存到线�E�本地变量中�?/div>
if (threadLocal.get() == null) {
try {
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
connection = DriverManager.getConnection(URL, USERNAME, PWD);
threadLocal.set(connection);
} catch (Exception e) {
e.printStackTrace();
}
}else {
return threadLocal.get();//直接�q�回�U�程本地变量
}
return connection;
}

public static void remove() {
threadLocal.remove();
}
}

package com.abin.lee.collection.threadlocal;
import java.io.Serializable;
public class UserBean implements Serializable{
private String id;
private String username;
private String password;

public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}

//��试代码
package com.abin.lee.collection.threadlocal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class OracleOperate {
public static List findAll(){
Connection conn=null;
PreparedStatement ps=null;
ResultSet rs=null;
String sql="select * from userbean order by id desc";
List list=new ArrayList();
UserBean user=null;
try {
conn=MyThreadLocal.getConnection();
ps=conn.prepareStatement(sql);
rs=ps.executeQuery();
while (rs.next()&&rs!=null) {
user=new UserBean();
user.setId(rs.getString("id"));
user.setUsername(rs.getString("username"));
user.setPassword(rs.getString("password"));
list.add(user);
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}
public static void main(String[] args) {
List list=findAll();
for(UserBean lst:list){
System.out.println("id="+lst.getId());
System.out.println("username="+lst.getUsername());
System.out.println("id="+lst.getPassword());
}
}
}

//ThreadLocal�W�二�U�用法：
package com.abin.lee.collection.threadlocal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class MyThreadLocal {
private static final String URL = "jdbc:oracle:thin:@localhost:1521:XE";
private static final String USERNAME = "abing";
private static final String PWD = "abing";
//使用ThreadLocal保存Connection变量
public static ThreadLocal threadLocal = new ThreadLocal(){
protected Connection initialValue() {
Connection connection = null;
//如果connThreadLocal没有本线�E�对应的Connection创徏一个新的Connection�Q��ƈ��其保存到线�E�本地变量中�?/div>
if (connection == null) {
try {
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
connection = DriverManager.getConnection(URL, USERNAME, PWD);
} catch (Exception e) {
e.printStackTrace();
}
}
return connection;
}

};

public static Connection getConnection() {
return threadLocal.get();
}
public static void remove() {
threadLocal.remove();
}
}

package com.abin.lee.collection.threadlocal;
import java.io.Serializable;
public class UserBean implements Serializable{
private String id;
private String username;
private String password;

public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}

package com.abin.lee.collection.threadlocal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class OracleOperate {
public static List findAll(){
Connection conn=null;
PreparedStatement ps=null;
ResultSet rs=null;
String sql="select * from userbean order by id desc";
List list=new ArrayList();
UserBean user=null;
try {
conn=MyThreadLocal.getConnection();
ps=conn.prepareStatement(sql);
rs=ps.executeQuery();
while (rs.next()&&rs!=null) {
user=new UserBean();
user.setId(rs.getString("id"));
user.setUsername(rs.getString("username"));
user.setPassword(rs.getString("password"));
list.add(user);
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}
public static void main(String[] args) {
List list=findAll();
for(UserBean lst:list){
System.out.println("id="+lst.getId());
System.out.println("username="+lst.getUsername());
System.out.println("id="+lst.getPassword());
}
}
}

abin 2012-09-01 17:03 发表评论

abin — Sat, 01 Sep 2012 07:56:00 GMT

package com.abin.lee.collection.volatiler;
public class MyThread implements Runnable{
private volatile boolean flag=false;
public void run() {
while(!flag){
try {
System.out.println("before");
Thread.sleep(3000);
System.out.println("after");
} catch (Exception e) {
e.printStackTrace();
}
flag=true;
}
}
public void setDone(boolean flag){
this.flag=flag;
}

}

��试代码�Q?br />
package com.abin.lee.collection.volatiler;
public class MyVolatileOne {
public static void main(String[] args) {
MyThread myThread=new MyThread();
Thread thread=new Thread(myThread);
thread.start();
}
}

abin 2012-09-01 15:56 发表评论

abin — Thu, 02 Aug 2012 07:30:00 GMT

问题解决2——加入�{�待与唤�?/strong>

package edu.sjtu.erplab.thread;

class Info{
    private String name="name";
    private String content="content";
    private boolean flag=true;
    public synchronized void set(String name,String content)
    {
        if(!flag)//标志位�ؓfalse�Q�不可以生��
        {
            try {
                super.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        this.setName(name);
        try {
            Thread.sleep(30);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        this.setContent(content);
        flag=false;//修改标志位�ؓfalse�Q�表�C�生产者已�l�完成资源，消费者可以消贏V�?br />        super.notify();//唤醒消费者进�E?br />    }

    public synchronized void get()
    {
        if(flag)
        {
            try {
                super.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(30);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(this.getName()+":-->"+this.getContent());
        flag=true;//修改标志位�ؓtrue�Q�表�C�消费者拿走资源，生��者可以生产�?br />        super.notify();//唤醒生��者进�E��?br />    }


    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }

}

class Producer implements Runnable{
    private Info info=null;
    public Producer(Info info)
    {
        this.info=info;
    }


    @Override
    public void run() {
        boolean flag=false;
        for(int i=0;i<10;i++)
            if(flag)
            {
                this.info.set("name+"+i, "content+"+i);
                flag=false;
            }
            else
            {
                this.info.set("name-"+i, "content-"+i);
                flag=true;
            }
    }
}

class Consumer implements Runnable{
    private Info info=null;
    public Consumer(Info info)
    {
        this.info=info;
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++)
        {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            this.info.get();
        }

    }
}

public class ThreadDeadLock {
    public static void main(String args[])
    {
        Info info=new Info();
        Producer pro=new Producer(info);
        Consumer con=new Consumer(info);
        new Thread(pro).start();
        new Thread(con).start();
    }

}

http://www.cnblogs.com/xwdreamer/archive/2011/11/20/2296931.html#2397397

abin 2012-08-02 15:30 发表评论

�_��的Java�U�程Sleep,yield,wait,notify,Synchronized

abin — Sat, 16 Jun 2012 17:42:00 GMT
多线�E?
�U�程�Q�是指进�E�中的一个执行流�E��?
�U�程与进�E�的区别�Q�每个进�E�都需要操作系�l��ؓ其分配独立的内存地址�I�间�Q�而同一�q�程中的所有线�E�在同一块地址�I�间中工作，�q�些�U�程可以�׃�n同一块内存和�pȝ��资源�?

如何创徏一个线�E�？

创徏�U�程有两�U�方式，如下�Q?
1�?扩展java.lang.Thread�c?
2�?实现Runnable接口
Thread�c�M��表线�E�类�Q�它的两个最主要的方法是�Q?
run()——包含�U�程�q�行时所执行的代�?
Start()——用于启动�U�程

一个线�E�只能被启动一�ơ。第二次启动时将会抛出java.lang.IllegalThreadExcetpion异常

�U�程间状态的转换�Q�如囄��Q?

新徏状态：用new语句创徏的线�E�对象处于新建状态，此时它和其它的java对象一��P��仅仅在堆中被分配了内�?
��q�A状态：当一个线�E�创��Z��以后�Q�其他的�U�程调用了它的start()�Ҏ��Q�该�U�程��p��入了��q�A状态。处于这个状态的�U�程位于可运行池中，�{�待获得CPU的��用权
�q�行状态：处于�q�个状态的�U�程占用CPU,执行�E�序的代�?
��d��状态：当线�E�处于阻塞状态时�Q�java虚拟��Z��会给�U�程分配CPU�Q�直到线�E�重新进入就�l�状态，它才有机会�{到运行状态�?
��d��状态分��Z��U�情况：
1�?位于对象�{�待池中的阻塞状态：当线�E�运行时�Q�如果执行了某个对象的wait()�Ҏ��Q�java虚拟机就回把�U�程攑ֈ��q�个对象的等待池�?
2�?位于对象锁中的阻塞状态，当线�E�处于运行状态时�Q�试图获得某个对象的同步锁时�Q�如果该对象的同步锁已经被其他的�U�程占用�Q�JVM��׃��把这个线�E�放到这个对象的琐池中�?
3�?其它的阻塞状态：当前�U�程执行了sleep()�Ҏ��Q�或者调用了其它�U�程的join()�Ҏ��Q�或者发��Z��I/O��h��Ӟ��׃��q�入�q�个状态中�?

��M��状态：当线�E�退��Z��run()�Ҏ��Q�就�q�入了死亡状态，该线�E�结束了生命周期�?
           或者正帔R��?
           或者遇到异帔R��?
           Thread�cȝ��isAlive()�Ҏ��判断一个线�E�是否活着�Q�当�U�程处于��M��状态或者新建状态时�Q�该�Ҏ��q�回false,在其余的状态下�Q�该�Ҏ��q�回true.

�U�程调度
�U�程调度模型�Q�分时调度模型和抢占式调度模�?
JVM采用抢占式调度模型�?
所谓的多线�E�的�q�发�q�行�Q�其实是指宏观上看，各个�U�程轮流获得CPU的��用权�Q�分别执行各自的��d��?
�Q�线�E�的调度不是跨��^収ͼ�它不仅取决于java虚拟机，它还依赖于操作系�l�）

如果希望明确地让一个线�E�给另外一个线�E�运行的��Z��Q�可以采取以下的办法之一
1�?调整各个�U�程的优先��
2�?让处于运行状态的�U�程调用Thread.sleep()�Ҏ��
3�?让处于运行状态的�U�程调用Thread.yield()�Ҏ��
4�?让处于运行状态的�U�程调用另一个线�E�的join()�Ҏ��

调整各个�U�程的优先��
Thread�cȝ��setPriority(int)和getPriority()�Ҏ��分别用来讄��优先�U�和��d��优先�U��?
如果希望�E�序能够�U�d��到各个操作�pȝ��中，应该��保在设�|�线�E�的优先�U�时�Q�只使用MAX_PRIORITY、NORM_PRIORITY、MIN_PRIORITY�q?个优先��?

�U�程睡眠�Q�当�U�程在运行中执行了sleep()�Ҏ��Ӟ��它就会放弃CPU�Q��{到阻塞状态�?
�U�程让步�Q�当�U�程在运行中执行了Thread�cȝ��yield()静态方法时�Q�如果此时具有相同优先��的其它线�E�处于就�l�状态，那么yield()�Ҏ��把当前�q�行的线�E�放到运行池中�ƈ使另一个线�E�运行。如果没有相同优先��的可�q�行�U�程�Q�则yield()�Ҏ��什么也不做�?
Sleep()�Ҏ��和yield()�Ҏ��都是Thread�cȝ��静态方法，都会使当前处于运行状态的�U�程攑ּ�CPU�Q�把�q�行��Z��让给别的�U�程�Q�两者的区别在于�Q?
         1、sleep()�Ҏ��会给其他�U�程�q�行的机会，而不考虑其他�U�程的优先��Q�因此会�l�较低线�E�一个运行的��Z��Q�yield()�Ҏ��只会�l�相同优先��或者更高优先��的线�E�一个运行的��Z��?
2、当�U�程执行了sleep(long millis)�Ҏ��后，��{到阻塞状态，参数millis指定睡眠旉��Q�当�U�程执行了yield()�Ҏ��后，��{到就�l�状态�?
          3、sleep()�Ҏ��声明抛出InterruptedException异常�Q�而yield()�Ҏ��没有声明抛出��M��异常
          4、sleep()�Ҏ��比yield()�Ҏ��h��更好的移植�?

�{�待其它�U�程的结束：join()
          当前�q�行的线�E�可以调用另一个线�E�的 join()�Ҏ��Q�当前运行的�U�程��{到阻塞状态，直到另一个线�E�运行结束，它才恢复�q�行�?

定时器Timer:在JDK的java.util包中提供了一个实用类Timer, 它能够定时执行特定的��d��?

�U�程的同�?
原子操作�Q�根据Java规范�Q�对于基本类型的赋值或者返回值操作，是原子操作。但�q�里的基本数据类型不包括long和double, 因�ؓJVM看到的基本存储单位是32位，而long 和double都要�?4位来表示。所以无法在一个时钟周期内完成�?

自增操作�Q?+�Q�不是原子操作，因�ؓ它涉及到一�ơ读和一�ơ写�?

原子操作�Q�由一�l�相关的操作完成�Q�这些操作可能会操纵与其它的�U�程�׃�n的资源，��Z��保证得到正确的运��结果，一个线�E�在执行原子操作光��Q�应该采取其他的措施使得其他的线�E�不能操�U�共享资源�?

同步代码块：��Z��保证每个�U�程能够正常执行原子操作�Q�Java引入了同步机�Ӟ��具体的做法是在代表原子操作的�E�序代码前加上synchronized标记�Q�这��L��代码被称为同步代码块�?

同步锁：每个JAVA对象都有且只有一个同步锁�Q�在��M��时刻�Q�最多只允许一个线�E�拥有这把锁�?

当一个线�E�试图访问带有synchronized(this)标记的代码块�Ӟ��必须获得 this关键字引用的对象的锁�Q�在以下的两�U�情况下�Q�本�U�程有着不同的命�q��?
1�?假如�q�个锁已�l�被其它的线�E�占用，JVM��׃��把这个线�E�放到本对象的锁池中。本�U�程�q�入��d��状态。锁池中可能有很多的�U�程�Q�等到其他的�U�程释放了锁�Q�JVM��׃��从锁池中随机取出一个线�E�，使这个线�E�拥有锁�Q��ƈ且�{到就�l�状态�?
2�?假如�q�个锁没有被其他�U�程占用�Q�本�U�程会获得这把锁�Q�开始执行同步代码块�?
�Q�一般情况下在执行同步代码块时不会释攑֐�步锁�Q�但也有�Ҏ��情况会释攑֯�象锁
如在执行同步代码块时�Q�遇到异常而导致线�E�终止，锁会被释放；在执行代码块�Ӟ��执行了锁所属对象的wait()�Ҏ��Q�这个线�E�会释放对象锁，�q�入对象的等待池中）

�U�程同步的特征：
1�?如果一个同步代码块和非同步代码块同时操作共享资源，仍然会造成对共享资源的竞争。因为当一个线�E�执行一个对象的同步代码块时�Q�其他的�U�程仍然可以执行对象的非同步代码块。（所谓的�U�程之间保持同步�Q�是指不同的�U�程在执行同一个对象的同步代码块时�Q�因��获得对象的同步锁而互相牵�Ӟ��
2�?每个对象都有唯一的同步锁
3�?在静态方法前面可以��用synchronized修饰�W��?
4�?当一个线�E�开始执行同步代码块�Ӟ��q�不意味着必须以不间断的方式运行，�q�入同步代码块的�U�程可以执行Thread.sleep()或者执行Thread.yield()�Ҏ��Q�此时它�q�不释放对象锁，只是把运行的��Z��让给其他的线�E��?
5�?Synchronized声明不会被��承，如果一个用synchronized修饰的方法被子类覆盖�Q�那么子�c�M��q�个�Ҏ��不在保持同步�Q�除非用synchronized修饰�?

�U�程安全的类�Q?
1�?�q�个�cȝ��对象可以同时被多个线�E�安全的讉K��?
2�?每个�U�程都能正常的执行原子操作，得到正确的结果�?
3�?在每个线�E�的原子操作都完成后�Q�对象处于逻辑上合理的状态�?

释放对象的锁�Q?
1�?执行完同步代码块��׃��释放对象的锁
2�?在执行同步代码块的过�E�中�Q�遇到异常而导致线�E�终止，锁也会被释放
3�?在执行同步代码块的过�E�中�Q�执行了锁所属对象的wait()�Ҏ��Q�这个线�E�会释放对象锁，�q�入对象的等待池�?

死锁
当一个线�E�等待由另一个线�E�持有的锁，而后者正在等待已被第一个线�E�持有的锁时�Q�就会发生死锁。JVM不监��也不试��N��免这�U�情况，因此保证不发生死锁就成了�E�序员的责�Q�?

如何避免死锁
一个通用的经验法则是�Q�当几个�U�程都要讉K��׃�n资源A、B、C �Ӟ��保证每个�U�程都按照同��L��序去访问他们�?

�U�程通信
Java.lang.Object�c�M��提供了两个用于线�E�通信的方�?
1�?wait():执行了该�Ҏ��的线�E�释攑֯�象的锁，JVM会把该线�E�放到对象的�{�待池中。该�U�程�{�待其它�U�程唤醒
2�?notify():执行该方法的�U�程唤醒在对象的�{�待池中�{�待的一个线�E�，JVM从对象的�{�待池中随机选择一个线�E�，把它转到对象的锁池中�?img src ="http://www.aygfsteel.com/stevenjohn/aggbug/380945.html" width = "1" height = "1" />

abin 2012-06-17 01:42 发表评论

abin — Sat, 16 Jun 2012 17:41:00 GMT

来自�Q�开发者在�U? Java多线�E�程序设计详�l�解�? 一、理解多�U�程多线�E�是�q�样一�U�机�Ӟ��它允许在�E�序中�ƈ发执行多个指令流�Q�每个指令流都称��Z��个线�E�，彼此间互相独立�? �U�程又称��量��q�程�Q�它和进�E�一��h��有独立的执行控制�Q�由操作�pȝ��负责调度�Q�区别在于线�E�没有独立的存储�I�间�Q�而是和所属进�E�中的其它线�E�共享一个存储空��_��q��得线�E�间的通信�q�较�q�程��单�? 多个�U�程的执行是�q�发的，也就是在逻辑�?#8220;同时”�Q�而不��是否是物理上的“同时”。如果系�l�只有一个CPU�Q�那么真正的“同时”是不可能的，但是�׃��CPU的速度非常快，用户感觉不到其中的区别，因此我们也不用关心它�Q�只需要设惛_��个线�E�是同时执行卛_��? 多线�E�和传统的单�U�程在程序设计上最大的区别在于�Q�由于各个线�E�的控制��彼此独立，使得各个�U�程之间的代码是乱序执行的，由此带来的线�E�调度，同步�{�问题，��在以后探讨�? 二：在Java中实现多�U�程我们不妨设想�Q��ؓ了创��Z��个新的线�E�，我们需要做些什么？很显�Ӟ��我们必须指明�q�个�U�程所要执行的代码�Q�而这��是在Java中实现多�U�程我们所需要做的一切！真是��奇�Q�Java是如何做到这一点的�Q�通过�c�！作�ؓ一个完全面向对象的语言�Q�Java提供了类java.lang.Thread来方便多�U�程�~�程�Q�这个类提供了大量的�Ҏ��来方便我们控制自��q��各个�U�程�Q�我们以后的讨论都将围绕�q�个�c�进行�? 那么如何提供�l?Java 我们要线�E�执行的代码呢？让我们来看一�?Thread �c�R��Thread �c�L��重要的方法是run()�Q�它为Thread�cȝ��Ҏ��start()所调用�Q�提供我们的�U�程所要执行的代码。�ؓ了指定我们自��q��代码�Q�只需要覆盖它�Q? �Ҏ��一�Q��?Thread �c�，覆盖�Ҏ�� run()�Q�我们在创徏�?Thread �cȝ��子类中重�?run() ,加入�U�程所要执行的代码卛_��。下面是一个例子： public class MyThread extends Thread { int count= 1, number; public MyThread(int num) { number = num; System.out.println ("创徏�U�程 " + number); } public void run() { while(true) { System.out.println ("�U�程 " + number + ":计数 " + count); if(++count== 6) return; } } public static void main(String args[]) { for(int i = 0; i �?5; i++) new MyThread(i+1).start(); } } �q�种�Ҏ��单明了，�W�合大家的习惯，但是�Q�它也有一个很大的�~�点�Q�那��是如果我们的类已经从一个类�l�承�Q�如��程序必��ȝ��承自 Applet �c�）�Q�则无法再��?Thread �c�，�q�时如果我们又不惛_��立一个新的类�Q�应该怎么办呢�Q? 我们不妨来探索一�U�新的方法：我们不创建Thread�cȝ��子类�Q�而是直接使用它，那么我们只能��我们的�Ҏ��作�ؓ参数传递给 Thread �cȝ��实例�Q�有点类似回调函数。但�?Java 没有指针�Q�我们只能传递一个包含这个方法的�cȝ��实例�? 那么如何限制�q�个�c�d��d��含这一�Ҏ��呢？当然是��用接口！�Q�虽然抽象类也可满��Q�但是需要��承，而我们之所以要采用�q�种新方法，不就是�ؓ了避免��承带来的限制吗？�Q? Java 提供了接�?java.lang.Runnable 来支持这�U�方法�? �Ҏ��二：实现 Runnable 接口 Runnable接口只有一个方法run()�Q�我们声明自��q��c�d��现Runnable接口�q�提供这一�Ҏ��Q�将我们的线�E�代码写入其中，��完成了�q�一部分的�Q务。但是Runnable接口�q�没有�Q何对�U�程的支持，我们�q�必��d��建Thread�cȝ��实例�Q�这一炚w��过Thread�cȝ��构造函数public Thread(Runnable target);来实现。下面是一个例子： public class MyThread implements Runnable { int count= 1, number; public MyThread(int num) { number = num; System.out.println("创徏�U�程 " + number); } public void run() { while(true) { System.out.println ("�U�程 " + number + ":计数 " + count); if(++count== 6) return; } } public static void main(String args[]) { for(int i = 0; i �?5; i++) new Thread(new MyThread(i+1)).start(); } } 严格地说�Q�创建Thread子类的实例也是可行的�Q�但是必��L��意的是，该子�c�d��L��有覆�?Thread �cȝ�� run �Ҏ��Q�否则该�U�程执行的将是子�cȝ�� run �Ҏ��Q�而不是我们用以实现Runnable 接口的类�?run �Ҏ��Q�对此大家不妨试验一下�? 使用 Runnable 接口来实现多�U�程使得我们能够在一个类中包�Ҏ��有的代码�Q�有利于��装�Q�它的缺点在于，我们只能使用一套代码，若想创徏多个�U�程�q��各个�U�程执行不同的代码，则仍必须额外创徏�c�，如果�q�样的话�Q�在大多数情况下也许�q�不如直接用多个�c�d��别��?Thread 来得紧凑�? �l�g��所�q�ͼ�两种�Ҏ��各有千秋�Q�大家可以灵�z�运用�? 下面让我们一��h��研究一下多�U�程使用中的一些问题�? 三、线�E�的四种状�? 1. 新状态：�U�程已被创徏但尚未执行（start() ��未被调用）�? 2. 可执行状态：�U�程可以执行�Q�虽然不一定正在执行。CPU 旉��随时可能被分配给该线�E�，从而��得它执行�? 3. ��M��状态：正常情况�?run() �q�回使得�U�程��M��。调�?stop()�?destroy() 亦有同样效果�Q�但是不被推荐，前者会产生异常�Q�后者是强制�l�止�Q�不会释��N��? 4. ��d��状态：�U�程不会被分�?CPU 旉��Q�无法执行�? 四、线�E�的优先�U? �U�程的优先��代表该线�E�的重要�E�度�Q�当有多个线�E�同时处于可执行状态�ƈ�{�待获得 CPU 旉��Ӟ��U�程调度�pȝ��Ҏ��各个�U�程的优先��来决定给谁分�?CPU 旉��Q�优先��高的�U�程有更大的��Z��获得 CPU 旉��Q�优先��低的�U�程也不是没有机会，只是��Z��要小一些�Ş了�? 你可以调�?Thread �cȝ��Ҏ�� getPriority() �?setPriority()来存取线�E�的优先�U�，�U�程的优先��界于1(MIN_PRIORITY)�?0(MAX_PRIORITY)之间�Q�缺省是5(NORM_PRIORITY)�? 五、线�E�的同步 �׃��同一�q�程的多个线�E�共享同一片存储空��_��在带来方便的同时�Q�也带来了访问冲�H�这个严重的问题。Java语言提供了专门机制以解决�q�种冲突�Q�有效避免了同一个数据对象被多个�U�程同时讉K��? �׃��我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对�Ҏ��提出一套机�Ӟ��q�套机制��是 synchronized 关键字，它包括两�U�用法：synchronized �Ҏ��?synchronized 块�? 1. synchronized �Ҏ��Q�通过在方法声明中加入 synchronized关键字来声明 synchronized �Ҏ��。如�Q? public synchronized void accessVal(int newVal); synchronized �Ҏ��控制对类成员变量的访问：每个�c�d��例对应一把锁�Q�每�?synchronized �Ҏ��都必��获得调用该�Ҏ��的类实例的锁方能执行�Q�否则所属线�E�阻塞，�Ҏ��一旦执行，��q��占该锁，直到从该�Ҏ��q�回时才��锁释放�Q�此后被��d��的线�E�方能获得该锁，重新�q�入可执行状态�? �q�种机制��保了同一时刻对于每一个类实例�Q�其所有声明�ؓ synchronized 的成员函��C��臛_��只有一个处于可执行状态（因�ؓ臛_��只有一个能够获得该�c�d��例对应的锁）�Q�从而有效避免了�c�L��员变量的讉K��冲突�Q�只要所有可能访问类成员变量的方法均被声明�ؓ synchronized�Q��? �?Java 中，不光是类实例�Q�每一个类也对应一把锁�Q�这��h��们也可将�cȝ��静态成员函数声明�ؓ synchronized �Q�以控制其对�cȝ��静态成员变量的讉K��? synchronized �Ҏ��的缺��P��若将一个大的方法声明�ؓsynchronized ��会大大影响效率�Q�典型地�Q�若��线�E�类的方�?run() 声明�?synchronized �Q�由于在�U�程的整个生命期内它一直在�q�行�Q�因此将��D��它对本类��M�� synchronized �Ҏ��的调用都永远不会成功。当然我们可以通过��访问类成员变量的代码放��C��门的�Ҏ��中，��其声明�?synchronized �Q��ƈ在主�Ҏ��中调用来解决�q�一问题�Q�但�?Java 为我们提供了更好的解军_��法，那就�?synchronized 块�? 2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下： synchronized(syncObject) { //允许讉K��控制的代�? } synchronized 块是�q�样一个代码块�Q�其中的代码必须获得对象 syncObject �Q�如前所�q�ͼ�可以是类实例或类�Q�的锁方能执行，具体机制同前所�q�。由于可以针对�Q意代码块�Q�且可�Q意指定上锁的对象�Q�故灉|��性较高�? 六、线�E�的��d�� Z��解决对共享存储区的访问冲�H�，Java 引入了同步机�Ӟ��现在让我们来考察多个�U�程对共享资源的讉K��Q�显然同步机制已�l�不够了�Q�因为在��L��时刻所要求的资源不一定已�l�准备好了被讉K��Q�反�q�来�Q�同一时刻准备好了的资源也可能不止一个。�ؓ了解册��U�情况下的访问控刉��题，Java 引入了对��d��机制的支持�? ��d��指的是暂停一个线�E�的执行以等待某个条件发生（如某资源��q�A�Q�，学过操作�pȝ��的同学对它一定已�l�很熟悉了。Java 提供了大量方法来支持��d��Q�下面让我们逐一分析�? 1. sleep() �Ҏ��Q�sleep() 允许指定以毫�U��ؓ单位的一�D�|��间作为参敎ͼ�它��得线�E�在指定的时间内�q�入��d��状态，不能得到CPU 旉��Q�指定的旉��一�q�，�U�程重新�q�入可执行状态。典型地�Q�sleep() 被用在等待某个资源就�l�的情�Ş�Q�测试发现条件不满��后，让线�E�阻塞一�D�|��间后重新��试�Q�直到条件满��ؓ止�? 2. suspend() �?resume() �Ҏ��Q�两个方法配套��用，suspend()使得�U�程�q�入��d��状态，�q�且不会自动恢复�Q�必��d��对应的resume() 被调用，才能使得�U�程重新�q�入可执行状态。典型地�Q�suspend() �?resume() 被用在等待另一个线�E��生的�l�果的情形：��试发现�l�果�q�没有��生后�Q�让�U�程��d��Q�另一个线�E��生了�l�果后，调用 resume() 使其恢复�? 3. yield() �Ҏ��Q�yield() 使得�U�程攑ּ�当前分得�?CPU 旉��Q�但是不使线�E�阻塞，即线�E�仍处于可执行状态，随时可能再次分得 CPU 旉��。调�?yield() 的效果等价于调度�E�序认�ؓ该线�E�已执行了��够的旉��从而�{到另一个线�E��? 4. wait() �?notify() �Ҏ��Q�两个方法配套��用，wait() 使得�U�程�q�入��d��状态，它有两种形式�Q�一�U�允�?指定以毫�U��ؓ单位的一�D�|��间作为参敎ͼ�另一�U�没有参敎ͼ�前者当对应�?notify() 被调用或者超出指定时间时�U�程重新�q�入可执行状态，后者则必须对应�?notify() 被调用�? 初看��h��它们�?suspend() �?resume() �Ҏ��Ҏ��有什么分别，但是事实上它们是截然不同的。区别的核心在于�Q�前面叙�q�的所有方法，��d��旉��不会释放占用的锁�Q�如果占用了的话�Q�，而这一�Ҏ��法则相反�? 上述的核心区别导致了一�p�d��的细节上的区别�? 首先�Q�前面叙�q�的所有方法都隶属�?Thread �c�，但是�q�一对却直接隶属�?Object �c�，也就是说�Q�所有对象都拥有�q�一�Ҏ��法。初看�v来这十分不可思议�Q�但是实际上却是很自然的�Q�因��一�Ҏ��法阻塞时要释攑֍�用的锁，而锁是�Q何对象都��h��的，调用��L��对象�?wait() �Ҏ��D��U�程��d��Q��ƈ且该对象上的锁被释放�? 而调�?��L��对象的notify()�Ҏ��则导致因调用该对象的 wait() �Ҏ��而阻塞的�U�程中随机选择的一个解除阻塞（但要�{�到获得锁后才真正可执行�Q��? 其次�Q�前面叙�q�的所有方法都可在��M��位置调用�Q�但是这一�Ҏ��法却必须�?synchronized �Ҏ��或块中调用，理由也很��单，只有在synchronized �Ҏ��或块中当前线�E�才占有锁，才有锁可以释放�? 同样的道理，调用�q�一�Ҏ��法的对象上的锁必��Mؓ当前�U�程所拥有�Q�这��h��有锁可以释放。因此，�q�一�Ҏ��法调用必��L��|�在�q�样�?synchronized �Ҏ��或块中，该方法或块的上锁对象��是调用�q�一�Ҏ��法的对象。若不满��一条�g�Q�则�E�序虽然仍能�~�译�Q�但在运行时会出现IllegalMonitorStateException 异常�? wait() �?notify() �Ҏ��的上�q�特性决定了它们�l�常和synchronized �Ҏ��或块一起��用，��它们和操作�pȝ��的进�E�间通信机制作一个比较就会发现它们的�怼�性：synchronized�Ҏ��或块提供了类��g��操作�pȝ��原语的功能，它们的执行不会受到多�U�程机制的干扎ͼ�而这一�Ҏ��法则相当�?block 和wakeup 原语�Q�这一�Ҏ��法均声明�?synchronized�Q��? 它们的结合��得我们可以实现操作系�l�上一�p�d��_�֦�的进�E�间通信的算法（如信号量��法�Q�，�q�用于解军_��U�复杂的�U�程间通信问题。关�?wait() �?notify() �Ҏ��最后再说明两点�Q? �W�一�Q�调�?notify() �Ҏ��D��解除��d��的线�E�是从因调用该对象的 wait() �Ҏ��而阻塞的�U�程中随机选取的，我们无法预料哪一个线�E�将会被选择�Q�所以编�E�时要特别小心，避免因这�U�不��定性而��生问题�? �W�二�Q�除�?notify()�Q�还有一个方�?notifyAll() 也可起到�c�M��作用�Q�唯一的区别在于，调用 notifyAll() �Ҏ��把因调用该对象�?wait() �Ҏ��而阻塞的所有线�E�一�ơ性全部解除阻塞。当�Ӟ��只有获得锁的那一个线�E�才能进入可执行状态�? 谈到��d��Q�就不能不谈一谈死锁，略一分析��p��发现�Q�suspend() �Ҏ��和不指定��时期限�?wait() �Ҏ��的调用都可能产生死锁。遗憄��是，Java �q�不在语�a��U�别上支持死锁的避免�Q�我们在�~�程中必��d��心地避免死锁�? 以上我们�?Java 中实现线�E�阻塞的各种�Ҏ��作了一番分析，我们重点分析�?wait() �?notify()�Ҏ��Q�因为它们的功能最强大�Q��用也最灉|��Q�但是这也导致了它们的效率较低，较容易出错。实际��用中我们应该灉|��使用各种�Ҏ��Q�以便更好地辑ֈ�我们的目的�? 七、守护线�E? 守护�U�程是一�cȝ��D�的�U�程�Q�它和普通线�E�的区别在于它�ƈ不是应用�E�序的核心部分，当一个应用程序的所有非守护�U�程�l�止�q�行�Ӟ��即��仍然有守护线�E�在�q�行�Q�应用程序也��终止，反之�Q�只要有一个非守护�U�程在运行，应用�E�序��׃��会终止。守护线�E�一般被用于在后��Cؓ其它�U�程提供服务�? 可以通过调用�Ҏ�� isDaemon() 来判断一个线�E�是否是守护�U�程�Q�也可以调用�Ҏ�� setDaemon() 来将一个线�E�设为守护线�E��? 八、线�E�组 �U�程�l�是一�?Java �Ҏ��的概念，�?Java 中，�U�程�l�是�c�ThreadGroup 的对象，每个�U�程都隶属于唯一一个线�E�组�Q�这个线�E�组在线�E�创建时指定�q�在�U�程的整个生命期内都不能更改�? 你可以通过调用包含 ThreadGroup �c�d��参数�?Thread �c�L��造函数来指定�U�程属的�U�程�l�，若没有指定，则线�E�缺省地隶属于名�?system 的系�l�线�E�组�? �?Java 中，除了预徏的系�l�线�E�组外，所有线�E�组都必��L��式创建。在 Java 中，除系�l�线�E�组外的每个�U�程�l�又隶属于另一个线�E�组�Q�你可以在创建线�E�组时指定其所隶属的线�E�组�Q�若没有指定�Q�则�~�省地隶属于�pȝ��U�程�l�。这��P��所有线�E�组�l�成了一��以�pȝ��U�程�l��ؓ根的树�? Java 允许我们对一个线�E�组中的所有线�E�同时进行操作，比如我们可以通过调用�U�程�l�的相应�Ҏ��来设�|�其中所有线�E�的优先�U�，也可以启动或��d��其中的所有线�E��? Java 的线�E�组机制的另一个重要作用是�U�程安全。线�E�组机制允许我们通过分组来区分有不同安全�Ҏ��的�U�程�Q�对不同�l�的�U�程�q�行不同的处理，�q�可以通过�U�程�l�的分层�l�构来支持不对等安全措施的采用�? Java �?ThreadGroup �c�L��供了大量的方法来方便我们对线�E�组树中的每一个线�E�组以及�U�程�l�中的每一个线�E�进行操作�? 九、�ȝ�� 在本文中�Q�我们讲�q�C�� Java 多线�E�编�E�的�Ҏ��面面�Q�包括创建线�E�，以及对多个线�E�进行调度、管理。我们深刻认识到了多�U�程�~�程的复杂性，以及�U�程切换开销带来的多�U�程�E�序的低效性，�q�也促��我们认真地思考一个问题：我们是否需要多�U�程�Q�何旉��要多�U�程�Q? 多线�E�的核心在于多个代码块�ƈ发执行，本质特点在于各代码块之间的代码是乱序执行的。我们的�E�序是否需要多�U�程�Q�就是要看这是否也是它的内在特点�? 假如我们的程序根本不要求多个代码块�ƈ发执行，那自然不需要��用多�U�程�Q�假如我们的�E�序虽然要求多个代码块�ƈ发执行，但是却不要求乱序�Q�则我们完全可以用一个��@环来��单高效地实现�Q�也不需要��用多�U�程�Q�只有当它完全符合多�U�程的特�Ҏ��Q�多�U�程机制对线�E�间通信和线�E�管理的强大支持才能有用武之圎ͼ��q�时使用多线�E�才是值得的�? 来自�Q�开发者在�U? 另外如果你喜�Ƣ电脑的话，我推荐你��d��学者之路看看~

abin 2012-06-17 01:41 发表评论

abin — Sat, 16 Jun 2012 17:15:00 GMT

�q�两个方法主要来源是�Q�sleep用于�U�程控制�Q�而wait用于�U�程间的通信�Q�与wait配套的方法还有notify和notifyAll.

区别一�Q?/p>
sleep是Thread�cȝ��Ҏ��Q�是�U�程用来控制自��n��程的，比如有一个要报时的线�E�，每一�U�中打印��Z��个时��_��那么我就需要在print�Ҏ��前面加上一个sleep让自己每隔一�U�执行一�ơ。就像个闚w��一栗��?/p>
wait是Object�cȝ��Ҏ��Q�用来线�E�间的通信�Q�这个方法会使当前拥有该对象锁的�q�程�{�待知道其他�U�程调用notify�Ҏ��时再醒来�Q�不�q�你也可以给他指定一个时��_��自动醒来。这个方法主要是用走不同�U�程之间的调度的�?/p>
区别�?�Q?/p>
关于锁的释放 �Q�在�q�里假设大家已经知道了锁的概念及其意义。调用sleep�Ҏ��不会释放锁（自己的感觉是sleep�Ҏ��本来��是和锁没有关系的，因�ؓ他是一个线�E�用于管理自��q��Ҏ��Q�不涉及�U�程通信�Q?/p>
JDK 7 中的解释�Q?/p>
“public static void sleep(long millis)

throws InterruptedException
Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.The thread does not lose ownership of any monitors.

public final void wait() throws InterruptedException
Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.“
调用wait�Ҏ��会释攑ֽ�前线�E�的锁（其实�U�程间的通信是靠对象来管理的�Q�所有操作一个对象的�U�程是这个对象通过自己的wait�Ҏ��来管理的�Q�就好像�q�个对象是电视机�Q�三个�h是三个线�E�，那么电视机的遥控器就是这个锁�Q�假如现在A拿着遥控器，电视��用wait�Ҏ��Q�那么A��׃��q��遥控器，由jVM虚拟��度，遥控器该交给谁。）【我惛_��一个好玩的例子�Q�如果A拉K��控器的期��_��他可以用自己的sleep每隔十分钟调一�ơ电视台�Q�而在他调��C��息的十分钟期��_��遥控器还在他的手上~�?/p>
区别三：

使用区域

�׃��wait函数的特�D�意义，所以他是应该放在同步语句块中的�Q�这��h��有意�?�?/p>
注意�Q�两个方法都需要抛出异�?/p>
个�h见解�Q�有sleep和wait的第二个区别�Q�引起了我对Java�U�程机制的一个疑问，目前�q�没有看�q�JDk�q�方面的源码�Q�其实看了，是木有看懂）�Q�线�E�的同步��理�Q�是不是由对象在调度�Q�如果是对象在调度，那么JDK 1.5新引入的ReentrantLock机制��比synchronized关键字更值得提倡。因��Z��更能反映��么一个机制来。好多�h不能理解wait和sleep的区别，我认为就是因为synchronized关键字的影响。当然自��p��不懂JAVA的线�E�具体实玎ͼ�留作疑问以后有时间��l�研�I�吧

Java中的多线�E�是一�U?strong>抢占式的机制 而不是分时机制。抢占式机制指的是有多个�U�程处于可运行状态，但是只有一个线�E�在�q�行�?/span>

共同点：
1. 他们都是在多�U�程的环境下�Q�都可以在程序的调用处阻塞指定的毫秒敎ͼ��q�返回�?br />
2. wait()和sleep()都可以通过interrupt()�Ҏ��打断�U�程的暂停状态，从而�ɾU�程立刻抛出InterruptedException�?br />   如果�U�程A希望立即�l�束�U�程B�Q�则可以对线�E�B对应的Thread实例调用interrupt�Ҏ��。如果此�ȝ��E�B正在wait/sleep /join�Q�则�U�程B会立��L��出InterruptedException�Q�在catch() {} 中直接return卛_��安全地结束线�E��?br />   需要注意的是，InterruptedException是线�E�自�׃��内部抛出的，�q�不是interrupt()�Ҏ��抛出的。对某一�U�程调用 interrupt()�Ӟ��如果该线�E�正在执行普通的代码�Q�那么该�U�程�Ҏ��׃��会抛出InterruptedException。但是，一旦该�U�程�q�入�?wait()/sleep()/join()后，��׃��立刻抛出InterruptedException�?br />
不同点：
1. Thread�cȝ��Ҏ��Q�sleep(),yield()�{?br />   Object的方法：wait()和notify()�{?br />
2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互�Q�来实现�U�程的同步�?br />   sleep�Ҏ��没有释放锁，而wait�Ҏ��释放了锁�Q��得其他线�E�可以��用同步控制块或者方法�?br />
3. wait�Q�notify和notifyAll只能在同步控制方法或者同步控制块里面使用�Q�而sleep可以在�Q何地方��?br />4. sleep必须捕获异常�Q�而wait�Q�notify和notifyAll不需要捕获异�?nbsp;

�U�程的调�?
        �U�程调度器按�U�程的优先��高低选择高优先��U�程�Q�进入运行中状态）执行�Q�同时线�E�调度是抢先式调度，卛_��果在当前�U�程执行�q�程中，一个更高优先��的线�E�进入可�q�行状态，则这个线�E�立卌��调度执行�?

抢先式调度又分�ؓ�Q�时间片方式和独占方式。在旉��片方式下�Q�当前活动线�E�执行完当前旉��片后�Q�如果有其他处于��q�A状态的相同优先�U�的�U�程�Q�系�l�会��执行权交给其他��q�A态的同优先��U�程�Q�当前活动线�E��{入等待执行队列，�{�待下一个时间片的调度�?
在独占方式下�Q�当前活动线�E�一旦获得执行权�Q�将一直执行下去，直到执行完毕或由于某�U�原因主动放弃CPU�Q�或者是有一高优先��的线�E�处于就�l�状态�?/font>

abin 2012-06-17 01:15 发表评论

abin — Wed, 06 Jun 2012 06:19:00 GMT

sleep,wait,suspend,resume,join,interrupt,stop,destory

abin 2012-06-06 14:19 发表评论

abin — Tue, 22 May 2012 07:19:00 GMT

�q�程和程序区别和联系表现在以下方面： 1)�E�序只是一�l�指令的有序集合�Q�它本��n没有��M��q�行的含义，它只�? 一个静态的实体。而进�E�则不同�Q�它是程序在某个数据集上的执行�? �q�程是一个动态的实体�Q�它有自��q��生命周期。它因创��生，�? 调度而运行，因等待资源或事�g而被处于�{�待状态，因完成�Q务而被撤消。反映了一个程序在一定的数据集上�q�行的全部动态过�E��? 2)�q�程和程序�ƈ不是一一对应的，一个程序执行在不同的数据集上就�? ��Z��同的�q�程�Q�可以用�q�程控制块来唯一地标识每个进�E�。而这一�? 正是�E�序无法做到的，�׃��E�序没有和数据��生直接的联系�Q�既使是执行不同的数据的�E�序�Q�他们的指��o的集合依然是一��L��Q�所以无�? 唯一地标识出�q�些�q�行于不同数据集上的�E�序。一般来��_��一个进�E? 肯定有一个与之对应的�E�序�Q�而且只有一个。而一个程序有可能没有与之对应的进�E?因�ؓ它没有执�?,也有可能有多个进�E�与之对�?�q? 行在几个不同的数据集�?�? 3)�q�程�q�具有�ƈ发性和交往性，�q�也与程序的��闭性不同�? ---------------------------------------------------------------------------------------------- �q�程和线�E�都是由操作�pȝ��所体会的程序运行的基本单元�Q�系�l�利用该基本单元实现�pȝ��对应用的�q�发性。进�E�和�U�程的区别在于： ��而言�?一个程序至��有一个进�E?一个进�E�至��有一个线�E? �U�程的划分尺度小于进�E�，使得多线�E�程序的�q�发性高�? 另外�Q�进�E�在执行�q�程中拥有独立的内存单元�Q�而多个线�E�共享内存，从而极大地提高了程序的�q�行效率�? �U�程在执行过�E�中与进�E�还是有区别的。每个独立的�U�程有一个程序运行的入口、顺序执行序列和�E�序的出口。但是线�E�不能够独立执行�Q�必��M��存在应用�E�序中，由应用程序提供多个线�E�执行控制�? 从逻辑角度来看�Q�多�U�程的意义在于一个应用程序中�Q�有多个执行部分可以同时执行。但操作�pȝ��q�没有将多个�U�程看做多个独立的应用，来实现进�E�的调度和管理以及资源分配。这��是�q�程和线�E�的重要区别�? �q�程是具有一定独立功能的�E�序关于某个数据集合上的一�ơ运行活�?�q�程是系�l�进行资源分配和调度的一个独立单�? �U�程是进�E�的一个实�?是CPU调度和分�z��基本单位,它是比进�E�更��的能独立运行的基本单位.�U�程自己基本上不拥有�pȝ��资源,只拥有一点在�q�行中必不可��的资源(如程序计数器,一�l�寄存器和栈),但是它可与同属一个进�E�的其他的线�E�共享进�E�所拥有的全部资�? 一个线�E�可以创建和撤销另一个线�E?同一个进�E�中的多个线�E�之间可以�ƈ发执�? ---------------------------------------------------------------------------------------------- �q�程和线�E�的区别说法一�Q�进�E�是��h��一定独立功能的�E�序关于某个数据集合上的一�ơ运行活�?�q�程是系�l�进行资源分配和调度的一个独立单�? �U�程是进�E�的一个实�?是CPU调度和分�z��基本单位,它是比进�E�更��的能独立运行的基本单位.�U�程自己基本上不拥有�pȝ��资源,只拥有一点在�q�行中必不可��的资源(如程序计数器,一�l�寄存器和栈),但是它可与同属一个进�E�的其他的线�E�共享进�E�所拥有的全部资�? 一个线�E�可以创建和撤销另一个线�E?同一个进�E�中的多个线�E�之间可以�ƈ发执�? 说法二：�q�程和线�E�都是由操作�pȝ��所体会的程序运行的基本单元�Q�系�l�利用该基本单元实现�pȝ��对应用的�q�发性。进�E�和�U�程的区别在于： ��而言�?一个程序至��有一个进�E?一个进�E�至��有一个线�E? �U�程的划分尺度小于进�E�，使得多线�E�程序的�q�发性高�? 另外�Q�进�E�在执行�q�程中拥有独立的内存单元�Q�而多个线�E�共享内存，从而极大地提高了程序的�q�行效率�? �U�程在执行过�E�中与进�E�还是有区别的。每个独立的�U�程有一个程序运行的入口、顺序执行序列和�E�序的出口。但是线�E�不能够独立执行�Q�必��M��存在应用�E�序中，由应用程序提供多个线�E�执行控制�? 从逻辑角度来看�Q�多�U�程的意义在于一个应用程序中�Q�有多个执行部分可以同时执行。但操作�pȝ��q�没有将多个�U�程看做多个独立的应用，来实现进�E�的调度和管理以及资源分配。这��是�q�程和线�E�的重要区别�? 说法三：多线�E�共存于应用�E�序中是��C��操作�pȝ��中的基本特征和重要标志。用�q�UNIX操作�pȝ��的读者知道进�E�，在UNIX操作�pȝ��中，每个应用�E�序的执行都在操作系�l�内�怸�登记一个进�E�标志，操作�pȝ��Ҏ��分配的标志对应用�E�序的执行进行调度和�pȝ��资源分配�Q�但�q�程和线�E�有什么区别呢�Q? �q�程和线�E�都是由操作�pȝ��所体会的程序运行的基本单元�Q�系�l�利用该基本单元实现�pȝ��对应用的�q�发性。进�E�和�U�程的区别在于： �U�程的划分尺度小于进�E�，使得多线�E�程序的�q�发性搞�? 另外�Q�进�E�在执行�q�程中拥有独立的内存单元�Q�而多个线�E�共享内存，从而极大地提高了程序的�q�行效率�? �U�程在执行过�E�中与进�E�还是有区别的。每个独立的�U�程有一个程序运行的入口、顺序执行序列和�E�序的出口。但是线�E�不能够独立执行�Q�必��M��存在应用�E�序中，由应用程序提供多个线�E�执行控制�? 从逻辑角度来看�Q�多�U�程的意义在于一个应用程序中�Q�有多个执行部分可以同时执行。但操作�pȝ��q�没有将多个�U�程看做多个独立的应用，来实现进�E�的调度和管理以及资源分配。这��是�q�程和线�E�的重要区别�? �q�程�Q�Process�Q�是最初定义在Unix�{�多用户、多��d��操作�pȝ��环境下用于表�C�应用程序在内存环境中基本执行单元的概念。以Unix操作�pȝ��Z��Q�进�E�是Unix操作�pȝ��环境中的基本成分、是�pȝ��资源分配的基本单位。Unix操作�pȝ��中完成的几乎所有用��L��理和资源分配�{�工作都是通过操作�pȝ��对应用程序进�E�的控制来实现的�? C、C++、Java�{�语�a��~�写的源�E�序�l�相应的�~�译器编译成可执行文件后�Q�提交给计算机处理器�q�行。这�Ӟ��处在可执行状态中的应用程序称��E�。从用户角度来看�Q�进�E�是应用�E�序的一个执行过�E�。从操作�pȝ��核心角度来看�Q�进�E�代表的是操作系�l�分配的内存、CPU旉��片等资源的基本单位，是�ؓ正在�q�行的程序提供的�q�行环境。进�E�与应用�E�序的区别在于应用程序作��Z��个静态文件存储在计算机系�l�的��盘�{�存储空间中�Q�而进�E�则是处于动态条件下由操作系�l�维护的�pȝ��资源��理实体。多��d��环境下应用程序进�E�的主要特点包括�Q? ●�q�程在执行过�E�中有内存单元的初始入口点，�q�且�q�程存活�q�程中始�l�拥有独立的内存地址�I�间�Q? ●�q�程的生存期状态包括创建、就�l�、运行、阻塞和��M��{�类型； ●从应用程序进�E�在执行�q�程中向CPU发出的运行指令�Ş式不同，可以��进�E�的状态分为用��h��和核心态。处于用��h��下的进�E�执行的是应用程序指令、处于核心态下的应用程序进�E�执行的是操作系�l�指令�? 在Unix操作�pȝ��启动�q�程中，�pȝ��自动创徏swapper、init�{�系�l�进�E�，用于��理内存资源以及对用戯��E�进行调度等。在Unix环境下无论是由操作系�l�创建的�q�程�q�要由应用程序执行创建的�q�程�Q�均拥有唯一的进�E�标识（PID�Q��? 说法四：应用�E�序在执行过�E�中存在一个内存空间的初始入口点地址、一个程序执行过�E�中的代码执行序列以及用于标识进�E�结束的内存出口点地址�Q�在�q�程执行�q�程中的每一旉��点均有唯一的处理器指��o与内存单元地址相对应�? Java语言中定义的�U�程�Q�Thread�Q�同样包括一个内存入口点地址、一个出口点地址以及能够��序执行的代码序列。但是进�E�与�U�程的重要区别在于线�E�不能够单独执行�Q�它必须�q�行在处于活动状态的应用�E�序�q�程中，因此可以定义�U�程是程序内部的��h��q�发性的��序代码��? Unix操作�pȝ��和Microsoft Windows操作�pȝ��支持多用戗��多�q�程的�ƈ发执行，而Java语言支持应用�E�序�q�程内部的多个执行线�E�的�q�发执行。多�U�程的意义在于一个应用程序的多个逻辑单元可以�q�发地执行。但是多�U�程�q�不意味着多个用户�q�程在执行，操作�pȝ��也不把每个线�E�作为独立的�q�程来分配独立的�pȝ��资源。进�E�可以创建其子进�E�，子进�E�与父进�E�拥有不同的可执行代码和数据内存�I�间。而在用于代表应用�E�序的进�E�中多个�U�程�׃�n数据内存�I�间�Q�但保持每个�U�程拥有独立的执行堆栈和�E�序执行上下文（Context�Q��? ��Z��上述区别�Q�线�E�也可以�U�Cؓ��d��q�程 (Light Weight Process�Q�LWP)。不同线�E�间允许��d��协作和数据交换，使得在计��机�pȝ��资源消耗等斚w��非常廉�h�? �U�程需要操作系�l�的支持�Q�不是所有类型的计算机都支持多线�E�应用程序。Java�E�序设计语言��线�E�支持与语言�q�行环境�l�合在一��P��提供了多��d��q�发执行的能力。这��好比一个�h在处理家务的�q�程中，��衣服放到洗衣机中自动洗涤后��大�c�x��在电饭锅里，然后开始做菜。等菜做好了�Q�饭熟了同时衣服也洗好了�? 需要注意的是：在应用程序中使用多线�E�不会增�?CPU 的数据处理能力。只有在多CPU 的计��机或者在�|�络计算体系�l�构下，��Java�E�序划分为多个�ƈ发执行线�E�后�Q�同时启动多个线�E�运行，使不同的�U�程�q�行在基于不同处理器的Java虚拟��Z��Q�才能提高应用程序的执行效率�?

参考资料：http://gdshang.blogchina.com/3305743.html

abin 2012-05-22 15:19 发表评论

激情福利在线,日韩一级完整毛片,日韩精品无码一区二区三区

Object之wait,notify,notifyAll

Future FutureTask

java�U�程�q�发库学�?-CyclicBarrier

java�U�程�q�发库学�?-Exchanger

Java 信号�?Semaphore 介绍

Java�q�发包中的几�U�ExecutorService

java多线�E?�q�回�l�果

如何快速处理十万条数据到数据库

java wait()与notify()

多线�E�题�?

Java 多线�E?加到100

Java volatile(一)

java中volatile关键字的含义

Java ThreadLocal

�_����的Java�U�程Sleep,yield,wait,notify,Synchronized

�_��的Java�U�程Sleep,yield,wait,notify,Synchronized