Java 线程

• 什么是线程

         根据多任务的原理，在一个程序内部也可以实现多个任务（顺序控制）的并发执行，

      其中的每一个任务被称为线程（Thread）。

       线程与进程的区别如下：

          1.每个进程都有独立的代码和数据空间（进程上下文），进程切换的开销大。

          2.线程:轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的

                运行栈和程序计数器（PC），线程切换的开销小。

          3.多进程：在操作系统中能同时运行多个任务（程序）

          4.多线程：在同一应用程序有多个顺序流同时执行。

•    Java的线程是通过java.lang.Thread类来实现的 。
•    每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操 作 的，方法run()称为线程体。

       例子1（创建线程的第一种方式）：

public class TestThread1 {
	public static  void main(String args[]){
		Runner1 r = new Runner1();
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		t1.start();
		t1.start();
	}
}
class Runner1 implements Runnable{
	public void run(){
		for(int i=0;i<30;i++){
			System.out.println("NO." + i);
		}
	}
}

   创建线程的步骤：

            1.定义一个类实现Runnable接口，重写其中的run()方法，加入所需的处理逻辑。

            2.创建Runnable接口实现类的对象。

            3.创建Thread类的对象（封装前面的Runnable接口实现类型对象）

            4.调用Thread对象的start()方法，启动线程。

   例子2：（创建线程的第二种方式）

public class TestThread2 {

	public static void main(String args[]){
		Thread t = new Runner2();
		t.setName("TestThread ");
		t.start();
	}
}

class Runner2 extends Thread{
	public void run(){
		for(int i=0; i < 30; i++){
			System.out.println(Thread.currentThread().getName() + i);
		}
	}
}

 两种方式的比较：

   1.使用Runnable接口创建线程：

      可以将CPU，代码和数据分开，形成清晰的模型。

      线程体run()方法所在的类还可以从其他类继承一些有用的属性或方法。

   2.直接继承Thread类创建线程：

      Thread子类无法再从其他类继承

      编写简单，run()方法的当前对象就是线程对象，可直操作。 

• 后台线程

         后台处理（Background Processing）

        后台线程（Background  Thread/Daemon Thread)

        用户线程(User Thread)

        主线程 (Main Thread)

        子线程(Sun Thread)

     Thread 类提供的相关方法：

     public final boolean isDaemon()

       判断是不是后台线程

     public final void setDaemon(Boolean on)

例子3：

public class TestDaemonThread {
	
	public static void main(String args[]){
		Thread t1 = new MyRunner(10);
		t1.setName("user thread t1");
		t1.start();
		
		Thread t2 = new MyRunner(100);
		t2.setDaemon(true);
		t2.setName("user thread t2");
		t2.start();
		
		for(int i=0; i<10; i++){
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
		System.out.println("main thread over!");
	}
}

class MyRunner extends Thread{
	private int n;
	public MyRunner(int n){
		this.n = n;
	}
	public void run(){
		for(int i=0; i<n; i++){
			System.out.println(this.getName() + ":" + i);
		}
		System.out.println(this.getName() + "over！");
	}
}

•  线程优先级

          线程的有机用数字来表示，范围从1到10。

          主线程的优先级是5，子线程的优先级默认与其父线程相同。

       Thread 类提供的相关方法：

           public final int getPriority()

          public final void setPriority()

       相关静态整型常量：

          Thread.MIN_PRIORITY=1

          Thread.MAX_PRIORITY=10

          Thread.NORM_PRIORITY=5

      注意：优先级设置并不可靠，所以实际应用中不用优先级来控制线程。

•  线程串行化

       在多线程程序中，如果在一个线程运行的过程中要用到另一个线程的运行

         结果，则可进行线程的串行化处理。

       Thread类提供的相关方法：

           public final void join()

           public final void join(long millis)

           public final void join(long millis,int nanos)

public class TestJoin {
	public static void main(String args[]){
		Runnable r = new MyRunner();
		Thread t = new Thread(r);
		t.start();
		try {
			t.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		for(int i=0; i<10; i++){
			System.out.println("main thread:" + i);
		}
	}
}
class MyRunner implements Runnable{
	public void run(){
		for(int i=0; i<30; i++){
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}

 运行结果：

Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9
Thread-0:10
Thread-0:11
Thread-0:12
Thread-0:13
Thread-0:14
Thread-0:15
Thread-0:16
Thread-0:17
Thread-0:18
Thread-0:19
Thread-0:20
Thread-0:21
Thread-0:22
Thread-0:23
Thread-0:24
Thread-0:25
Thread-0:26
Thread-0:27
Thread-0:28
Thread-0:29
main thread:0
main thread:1
main thread:2
main thread:3
main thread:4
main thread:5
main thread:6
main thread:7
main thread:8
main thread:9

•   线程休眠

     线程休眠--暂停执行当前运行中的线程，使之进入阻塞状态，待指定的“延迟时间”后再醒来并转入到就绪状态。

 Thread类提供的相关方法：

        public static void sleep(long millis)

        public static void sleeep(long millis,int nanos)

• 线程让步

         线程让步---让运行中的线程主动放弃当前获得CPU处理的机会，但不是使该线程阻塞，而是使之转入就绪状态。

         Thread 类提供的相关方法：

             public static void yield()

public class TestYield {
	public static void main(String args[]){
		
		Thread t1 = new MyThread(false);
		Thread t2 = new MyThread(true);
		Thread t3 = new MyThread(false);
		
		t1.start();
		t2.start();
		t3.start();
	}
}
class MyThread extends Thread{
	private boolean flag;
	public MyThread(boolean flag){
		this.flag = flag;
	}
	public void run(){
		long start = new Date().getTime();
		for(int i=0; i<30; i++){
			if(flag){
				Thread.yield();
			}
			System.out.println(Thread.currentThread().getName() + ":" + "\t");
		}
		long end = new Date().getTime();
		System.out.println("\n" + Thread.currentThread().getName() + "excute time:" + (end -start) + "millis");
	}
}

• 线程挂起和恢复

         线程挂起--暂时停止当前运行中的线程，使之转入阻塞状态，并不会自动恢复运行。

         线程恢复--使得一个已经挂起的线程恢复运行。

         Thread类提供的相关方法：

             public final void suspend()

             public final void resume()

•    终止线程运行

   提倡使用 ：

public class TerminateThread {
	public static void main(String args[]){
		Test r = new Test();
		Thread t = new Thread(r);
		t.start();
		for(int i=0; i<10; i++){
			try{
				Thread.sleep(5);
				System.out.println("\nin thread main i=" + i);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.println("Thread main is over.");
		r.shutDown();
	}
}
class Test implements Runnable{
	private boolean flag = true;
	public void run(){
		int i = 0;
		while (flag == true){
			System.out.println(" " + i++);
		}
	}
	public void shutDown(){
		this.flag = false;
	}
}

• 线程控制基本方法

           isAlive()

            判断线程是否还“活”着，即线程是否还未终止。

             getPriority()

             获得线程的优先级数值（不实用）

            setPriority()

               设置线程的优先级数值（不实用）

            sleep()

                将当前线程睡眠指定毫秒数。

             join()

               调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，

                   再恢复当前线程的运行。

             yield()

               让出CPU，当前线程就如就绪队列等待调度。

             suspend()/resume()

               挂起和恢复线程。

           wait()

             当前线程进入对象的wait pool

           notify()/notifyAll()

               唤醒对象的wait pool中的一个/所有的等待线程。

 

• 互斥锁

          在Java语言中，引入了对象互斥的概念，来保证共享数据操作的完整性。

          每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，

             只能有一个线程访问该对象。

          关键字synchronized来与对象的互斥联系。当某个对象用synchronized修饰时，

            表明该对象在任一时刻只能由一个线程访问。

• synchronized用法

        用于方法声明中，标明整个方法为同步方法：

          public synchronized void push(char c){

           data[idx] = c;

           idx++;

           }

           用于修饰语句块，表明整个语句块为同步块。

           public char pop(){

           synchronized(this){

               idx--;

               return data[idx];

           }

          }

• 线程死锁

         并发运行的多个线程间彼此等待，都无法运行的状态被称为线程死锁。