线程基础1一基本认识

一、程序、进程与线程

    程序：一组计算机可执行的指令序列的集合。

    进程：正在运行的程序。 

    线程：一个进程中有多个任务，每个任务可以通过一个线程来完成。一个线程是进程中一个单一的顺序控制流程。

二、线程的生命周期

    可将线程的生命周期分为6个状态：

    1、新建状态

当使用new一个新线程时，但还没有执行start(),线程还没有开始运行，这时线程的状态就是NEW状态。

    2、就绪状态（可运行状态）

            　当start()方法被调用时，线程就进入RUNNABLE状态

    3、运行状态

当run()方法被调用时

    4、等待状态

线程因为调用了wait()或join()而未运行，就会进入WAITING状态。

    5、阻塞状态

下列情况会进入阻塞状态：

　　 1.等待某个操作的返回，例如IO操作，该操作返回之前，线程不会继续下面的代码。

　　 2.等待某个“锁”，在其他线程或程序释放这个“锁”之前，线程不会继续执行。

　　 3.等待一定的触发条件。

　　 4.线程执行了sleep方法。

　　 5.线程被suspend()方法挂起。 

    6、终止状态

　　线程已运行完毕。它的run()方法已正常结束或通过抛出异常而结束。

三、线程的创建

    1、继承Thread类

      例:public class Thread_A  extends Thread{...};

          创建线程对象：

          Thread_A  thread_a =new Thread_A();

    2、实现Runnable接口

      例:public class Task  implements  Runnable{...};

         创建线程对象：

        Task  task=new  Task();

        Thread thread=new Thread(task);

        注：Runnable接口中只有run（）方法，实现Runnable接口的类可以在run（）方法中定义所执行的任务。若要将该任务通过线程来实现，需将实现Runnable接口的对象封装成为线程对象。

    3、内部类

       例： public void   methrod（方法名）{

          //其他程序代码

          new Thread（）{
            public void run（）{

               //线程执行操作

             }

          }.start（）;

       }

四、线程的方法

   1、start（）    

   调用start（）方法可以启动线程，线程进入就绪状态，当获得CPU资源时，自动调用run（）方法，进入运行状态执行操作。

   2、run（）

   run（）方法执行线程中的任务。         

   3、sleep（millis（毫秒数））

  调用该方法当前线程停止执行，进入休眠状态，休眠millis毫秒后重新进入就绪状态。

   4、wait（）、wait（millis）

   调用wait（）方法线程进入等待状态，其他线程调用notify（）或notifyAll（）方法可将其唤醒。

   wait(millis)方法线程进入等待状态，在millis内通过notify（）或notifyAll（）将其唤醒后，或在等待millis后线程自行放弃等待，进入就绪状态。

   5、notify（）、notifyAll

    将线程从等待状态唤醒

   6、join（）、join（millis）

    在当前线程中，某线程调用其join（）方法，该线程优先执行，当前线程停止执行，处于等待状态，当调用join（）的线程结束，当前线程才能开始运行。

   在当前线程中，某线程调用其join（millis）方法，该线程优先执行，当前线程停止执行，处于等待状态，等待millis后当前线程继续执行。

   7、yield（）

   暂停当前正在执行的线程。实际是将当前线程从运行状态回归就绪状态，以便相同优先级的其他线程获得运行机会（形象的称为让步）。使用yield（）方法目的是相同优先级的线程能适当轮换执行，避免一个线程独占CPU片段。但是实际上无法保证达到让步目的，让步的线程由于可能被线程调度程序选中，进入运行状态。

   8、interrupt()      

   调用interrupt（）方法可以中断线程。

 

五、线程的同步机制

    多线程机制可以同时进行多个任务，提升CPU的使用效率，但由于多个线程共享资源，会出现一些资源冲突的问题。Java针对这一问题提供了一种有效的机制来消除资源冲突—同步机制。

     同步机制使用synchronized关键字，当某线程执行synchronized修饰的程序段（访问的共享资源）时，监控器给该程序段加锁，表示该线程占有共享资源，直到这段程序执行完才释放锁。锁释放后其他线程才能访问这些资源。

例：

public class ThreadTest implements Runnable{
	int num=100;
	public void run(){
		while(true){
		   if(num>0){
			 try{
				 Thread.sleep(100);
			 }catch(Exception e){
				e.printStackTrace();
			 }
		   System.out.println("剩余票数"+num--);
	      }
		}
	}
	public static void main(String[] args){
		ThreadTest t=new ThreadTest();
		new Thread(t).start();
		new Thread(t).start();
		new Thread(t).start();
	}
}

运行结果会出现：

<span style="font-size:18px;">剩余票数2
剩余票数1
剩余票数0
剩余票数-1</span>

结果-1显然不符合实际情况。
解决方法：

  1、同步代码块

public void run(){
     while(true)
	   synchronized(this){
	         if(num>0){
		       try{
				Thread.sleep(100);
			 }catch(Exception e){
				e.printStackTrace();
			 }
		   System.out.println("剩余票数"+num--);
	          }
	  }
     }
}

  2、同步方法

	public synchronized void run(){
		while(true){
		 if(num>0){
		     try{
				 Thread.sleep(100);
			 }catch(Exception e){
				e.printStackTrace();
			 }
		   System.out.println("剩余票数"+num--);
	      }
		}
	 }