线程是java的内嵌特性，线程并不容易掌握，有专门介绍java线程的书籍，读者可以参考。由此可见java线程的重要性，本文将详细介绍线程的基本知识。

　　有的时候你可能想写一个程序，每隔一段时间执行相关的任务，这个时候你可以使用timer和timertask，非常方便。你可以参考使用java中的timer和timertask.

　　在java中实现一个线程有两种方法，第一是实现runnable接口实现它的run（）方法，第二种是继承thread类，覆盖它的run（）方法。下面是代码示例：

　　public class dosomething implements runnable {

　　public void run（）{

　　// here is where you do something

　　}

　　}

　　public class doanotherthing extends thread {

　　public void run（）{

　　// here is where you do something

　　}

　　}

　　这两种方法的区别是，如果你的类已经继承了其它的类，那么你只能选择实现runnable接口了，因为java只允许单继承的。

　　java中的线程有四种状态分别是：运行、就绪、挂起、结束。如果一个线程结束了也就说明他是一个死线程了。当你调用一个线程实例的start（）的方法的时候，这个时候线程进入就绪状态，注意并不是运行状态，当虚拟机开始分配给他cpu的运行时间片的时候线程开始进入运行状态，当线程进入等待状态，例如等待某个事件发生的时候，这时候线程处于挂起状态。

　　启动一个线程你只需要调用start（）方法，针对两种实现线程的方法也有两种启动线程的方法，分别如下：

　　dosomething doit = new dosomething（）；

　　thread mythread = new thread（ doit ）；

　　mythread.start（）；

　　doanotherthing doit = new doanotherthing（）；

　　doit.start（）；

　　由于安全等因素thread中的stop（）方法已经不推荐使用了，因此如果你想要停止一个线程的时候可以通过设置一个信号量，例如：

　　public class mythread implements runnable {

　　private boolean quit = false；

　　public void run（）{

　　while（ ！quit ）{

　　// do something

　　}

　　}

　　public void quit（）{

　　quit = true；

　　}

　　}

　　如果每个线程只做它自己的事情，那么就很简单了，但是有的时候几个线程可能要同时访问一个对象并可能对它进行修改，这个时候你必须使用线程的同步在方法或者代码块使用关键字synchronized，例如：

　　public class counter {

　　private int counter；

　　public synchronized int increment（）{

　　return ++counter；

　　}

　　public synchronized int decrement（）{

　　if（ ――counter < 0 ）{

　　counter = 0；

　　}

　　return counter；

　　}

　　}

　　每个java对象都可以最为一个监视器，当线程访问它的synchronized方法的时候，他只允许在一个时间只有一个线程对他访问，让其他得线程排队等候。这样就可以避免多线程对共享数据造成破坏。记住synchronized是会耗费系统资源降低程序执行效率的，因此一定要在需要同步的时候才使用，尤其在j2me的开发中要小心。如果你要是想让线程等待某个事件的发生然后继续执行的话，那么这就涉及到线程的调度了。在java中通过wait（），notify（），notifyall（）来实现，这三个方法是在object类中定义的，当你想让线程挂起的时候调用obj.wait（）方法，在同样的obj上调用notify（）则让线程重新开始运行。

　　最后以sun提供的producer/consumer的例子来结束这篇文章，内容是producer产生一个数字而consumer消费这个数字，这个小程序里面基本覆盖了本文所有的知识点。请详细研究一下代码

　　public class producer extends thread {

　　private cubbyhole cubbyhole；

　　private int number；

　　public producer（cubbyhole c， int number） {

　　cubbyhole = c；

　　this.number = number；

　　}

　　public void run（） {

　　for （int i = 0； i < 10； i++） {

　　cubbyhole.put（i）；

　　system.out.println（"producer #" + this.number

　　+ " put： " + i）；

　　try {

　　sleep（（int）（math.random（） * 100））；

　　} catch （interruptedexception e） { }

　　}

　　}

　　}

　　public class cubbyhole {

　　private int contents；

　　private boolean available = false；

　　public synchronized int get（） {

　　while （available == false） {

　　try {

　　wait（）；

　　} catch （interruptedexception e） { }

　　}

　　available = false；

　　notifyall（）；

　　return contents；

　　}

　　public synchronized void put（int value） {

　　while （available == true） {

　　try {

　　wait（）；

　　} catch （interruptedexception e） { }

　　}

　　contents = value；

　　available = true；

　　notifyall（）；

　　}

　　}

　　public class consumer extends thread {

　　private cubbyhole cubbyhole；

　　private int number；

　　public consumer（cubbyhole c， int number） {

　　cubbyhole = c；

　　this.number = number；

　　}

　　public void run（） {

　　int value = 0；

　　for （int i = 0； i < 10； i++） {

　　value = cubbyhole.get（）；

　　system.out.println（"consumer #" + this.number

　　+ " got： " + value）；

　　}

　　}

　　}

　　public class producerconsumertest {

　　public static void main（string[] args） {

　　cubbyhole c = new cubbyhole（）；

　　producer p1 = new producer（c， 1）；

　　consumer c1 = new consumer（c， 1）；

　　p1.start（）；

　　c1.start（）；

　　}

　　}

　　sun说输出的结果应该是如下形式，但是在我的机器上却不是这样的，做了一些改动才正确，有兴趣的朋友可以运行一下看看结果，欢迎和我讨论一下！

　　producer #1 put： 0

　　consumer #1 got： 0

　　producer #1 put： 1

　　consumer #1 got： 1

　　producer #1 put： 2

　　consumer #1 got： 2

　　producer #1 put： 3

　　consumer #1 got： 3

　　producer #1 put： 4

　　consumer #1 got： 4

　　producer #1 put： 5

　　consumer #1 got： 5

　　producer #1 put： 6

　　consumer #1 got： 6

　　producer #1 put： 7

　　consumer #1 got： 7

　　producer #1 put： 8

　　consumer #1 got： 8

　　producer #1 put： 9

　　consumer #1 got： 9