Java进击（四）线程

一、线程、进程、多线程 概念   

        首先明白线程是什么？线程是一个程序内部的顺序控制流。线程经常和进程搞混，进程是一次程序的执行；线程可以看成是轻量级的进程。多进程：在操作系统中可能同时运行多个任务；多线程：在同一应用程序中有多个顺序流同时执行。

二、线程创建和启动

          Java的线程是通过java.lang.Thread类实现的。每个线程都是通过某个特定Thread对象所对应的方法run（）来完成其操作的，方法run（）成为线程体。通过调用Thread类的start（）方法来启动一个线程。

          有两种方式创建新的线程：

           第一种：实现接口

                 （1）定义线程类实现Runnable接口

                 （2）Thread myThread = new Thread（target）

                  （3）runnable中只有一个方法：publicvoid run（）定义线程运行体

                  （4）使用Runnable接口可以为多个线程提供共享的数据

                  （5）在实现Runnable接口的类的run方法定义中可以使用Thread的静态方法：public static Thread currentThread()获取当前线程的引用

                   例子：

			public class RunnableDemo{
			public static void main(String[] args){
			//只创建一个实现Runnable接口类的对象
			   TestThread threadobj = new TestThread();
			   System.out.println("Starting threads");
			   //只用一个Runnable类型对象为参数创建三个新线程
			   new Thread(threadobj,"Thread1").start();
			   new Thread(threadobj,"Thread2").start();
			   new Thread(threadobj,"Thread3").start();
			   System.out.println("Threads started,main ends\n");
			}
			}
			
			class TestThread implements Runnable{
			   private int sleepTime;
			   //构造函数
			   public TestThread(){
			   //获取随机休息时间
			      sleepTime=(int)(Math.random()*6000);
			   }
			   public void run(){
			      try{
				     System.out.println(Thread.currentThread().getName()+"going to sleep for"+sleepTime);
					 Thread.sleep(sleepTime);
				  }catch(InterruptedException exception){
				  
				  }
				  System.out.println(Thread.currentThread().getName()+"finished");
			   }
			}

运行结果：

                     

  第二种：继承

                    （1）可以定义一个Thread的子类并重写run方法：

                                      class MyThread extends Thread｛

                                                    public void run（）｛…｝

                                        ｝

                     （2）然后生成该类的对象：

                                        MyThread myThread=newsMyThread（…）

            例子：

			public class ExtendsDemo{
			   public static void main(String[] args){
			   //创建并命名每个线程
			                      TestThread thread1=new TestThread("thread1");
					TestThread thread2=new TestThread("thread2");
					TestThread thread3=new TestThread("thread3");
					
					System.out.println("Starting threads");
					//启动线程
					thread1.start();
					thread2.start();
					thread3.start();
					
					System.out.println("Threads started,main ends\n");	
			  }
			}
			class TestThread extends Thread{
			   private int sleepTime;
			   //构造函数
			   public TestThread(String name)
			   {
			      super(name);
				  sleepTime=(int)(Math.random()*6000);
			   }
			   public void run(){
			      try{
				     System.out.println(getName()+"going to sleep for"+sleepTime);
					 Thread.sleep(sleepTime);
				  }catch(InterruptedException exception){
				    
				  }
				   System.out.println(getName()+"finished");
			   }
			
			}

运行结果：

                                          

        通过以上两种方法都可以创建线程，那么这两种方法有什么特点，我们分析一下：通过以上两个例子，通过运行结果我们看到实现Runnable接口方法创建的线程可以共享一个资源sleepTime，而继承Thread方法创建的线程没有共享一个资源，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。(需要注意一个子类只能继承一个父类，但是可以实现多个接口)

   

    优缺点：

     采用继承Thread类方式：
         （1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
         （2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
    采用实现Runnable接口方式：
         （1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标(target)对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
         （2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。 

            

         在实际应用中根据情况选择合适的方法。

 

三、生产者--消费者

           现实中我们经常会遇到很多有趣的情况：同时运行的几个线程需要共享一些数据，并且要考虑到彼此的状态和动作。比如在一个线程对共享数据进行操作时，在没完成相关操作之前，不允许其他线程打断，否则会破坏数据的完整性。也就是说，被多个线程共享的数据在同一时刻只运行一个线程处于操作之中，这就是同步控制中的一个问题——线程间的互斥。

            我们模拟存票售票的例子感受一下：

		public class SaveSellTickets{
		  public static void main(String[] args){
		     Tickets t =new Tickets(10);
			 new Producer(t).start();
			 new Consumer(t).start();
		  }
		}
		
		class Tickets{
		  int number=0;
		  int size;
		  boolean available =false;
		  public Tickets(int size){
		    this.size=size;
		  }
		}
		
		class Producer extends Thread{
		  Tickets t = null;
		  public Producer(Tickets t){
		    this.t = t;
		  }
		  public void run(){
		    while(t.number<t.size){
			   System.out.println("Producer puts ticket"+(++t.number));
			   t.available=true;
			}
		  }
		}
		
		class Consumer extends Thread{
		Tickets t =null;
		 int i=0;
		 public Consumer(Tickets t){
		    this.t = t;
		 }
		 public void run(){
		  while(i<t.size){
		     if(t.available ==true && i <= t.number){
			    System.out.println("Consumer buys ticket"+(++i));
				if(i==t.number){
				try{
				  Thread.sleep(5000);}catch(InterruptedException exception){};
				  t.available =false;
				}
			 }
		  }
		 }
		}

运行结果：

                                       

              现在是卖10张票，我们多卖些看看会出现什么情况，多运行几次会发现有时候程序就陷入死机了，为什么？仔细想想，如果程序运行到t.available=false之前，cpu切换到执行存票程序，存票将available置为true，但再次切换到售票之后，售票线程执行t.available=false，则由于售票序号大于总票数，且存票结束不再重置为true，那么程序陷入死循环。那么如何避免这种意外呢？

                      在java中，利用“锁旗标”可以实现线程间的互斥操作。看看如何修改代码：

最终优化，将两个需要互斥的方法放在Tickets类中实现：

		public class NewTickets{
		  public static void main (String[] args){
		      Tickets t = new Tickets(10);
			  new Producer(t).start();
			  new Consumer(t).start();
		 }
		}
		class Tickets{
		 int number=0;
		  int size;
		  int i = 0;
		  boolean available =false;
		  public Tickets(int size){
		    this.size=size;
		  }
		  public synchronized void put(){
		   System.out.println("Producer puts ticket"+(++number));
		   available=true;
		  }
		  public synchronized void sell(){
		    if(available == true && i <=number)	
			System.out.println("Consumer buys ticket"+(++i));
			if(i ==number) available=false;
		  }
		}
		class Producer extends Thread{
		Tickets t=null;
		public Producer(Tickets t){
		  this.t=t;
		}
		public void run(){
		while(t.number<t.size)
		t.put();
		}
		}
		
		class Consumer extends Thread{
		  Tickets t=null;
		  public Consumer(Tickets t){
		     this.t=t;
		  }
		  public void run(){
		    while(t.i<t.size)
			t.sell();
		  }
		}

四、线程间通信

            当线程在继续执行前需要等待一个条件时，仅有 synchronized 关键字是不够的。虽然 synchronized关键字阻止并发更新一个对象，但它没有实现线程间发信。Object 类为此提供了三个函数：wait()、notify() 和 notifyAll()。

           还以售票为例子，要求存入一张票就售出一张票，售出后再存入，看代码：

		class Tickets{
		 int number=0;
		  int size;
		  int i = 0;
		  boolean available =false;
		  public Tickets(int size){
		    this.size=size;
		  }
		  public synchronized void put(){
		  if(available)//如果还有票剩余则存票等带
		  try{wait();}catch(Exception e){}
		   System.out.println("Producer puts ticket"+(++number));
		   available=true;
		   notify();//存入后唤醒售票
		  }
		  public synchronized void sell(){
		    if(! available)//如果没有存票则售票等待
			try{wait();}catch(Exception e){}
			System.out.println("Consumer buys ticket"+(number));
			available=false;
			notify();//售票后唤醒存票
			if(number == size) number=size+1;	  	
		  }
		}

只需修改 Tickets 类的 put 和 sell 方法，结果如下：

                                                           

五、总结

                 线程还有很多需要学习的东西，有效利用多线程的关键是理解程序是并发执行而不是串行执行的。比如程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。通过对多线程的使用，可以编写出非常高效的程序。不过值得注意的是，如果创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。在真正应用中，线程还有很多需要注意和思考的地方。

        不足之处，敬请指正~~~