多线程重要方法的使用

　　首先讲一下进程和线程的区别：

　　　　进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。

　　　　线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。

　　　　线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。

　　　　多进程是指操作系统能同时运行多个任务（程序）。

　　　　多线程是指在同一程序中有多个顺序流在执行。

　　在java中创建一个线程有两种方法：

　　　　①实现java.lang.Runnable接口，重写run()方法，启动：new Thread(this).start()。

package com.taobao.tina.test;

/**
 * @author Tina
 *
 */
public class ThreadTest1 {

	    public static void main(String[] args) {
	        Runnable1 r = new Runnable1();
	        //r.run();并不是线程开启，而是简单的方法调用
	        Thread t = new Thread(r);//创建线程
	        //t.run(); //如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
	        t.start(); //线程开启
	        for (int i = 0; i < 100; i++) {
	            System.out.println("main:"+i);
	        }
	    }
	}
	class Runnable1 implements Runnable{
	    public void run() {
	        for (int i = 0; i < 100; i++) {
	            System.out.println("Thread-----:"+i);
	        }
	    }
	}

　要注意的是：

　　　　1.r.run()并不是启动线程，而是简单的方法调用。

　　　　2.Thread也有run()方法，如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

　　　　3.并不是一启动线程（调用start()方法）就执行这个线程，而是进入就绪状态，什么时候运行要看CUP。

　　　　②继承java.lang.Thread类，重写run()方法。

package com.taobao.tina.test;

/**
 * @author Tina
 *
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        Thread1 t = new Thread1();
        //t.run(); //这里也不能直接调用方法
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main:"+i);
        }
    }
}

//尽量使用实现Runnnable接口，因为接口比较灵活
class Thread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread-----:"+i);
        }
    }
  }

虽然两种方法都可行，但是最好还是用第一种方法，因为使用接口灵活性好，java中时单继承、多实现。

Thread类中常用的方法有：

　　①sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。

package com.taobao.tina.test;

import java.util.Date;

/**
 * @author Tina
 *
 */
public class SleepTest {

	 public static void main(String[] args) {
	        Thread2 t = new Thread2();
	        t.start();
	        try {
	            Thread.sleep(10000); //主线程睡眠10秒钟
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	        //主线程睡眠10秒钟后结束t线程
	        //t.interrupt(); //这种结束方式比较粗暴，如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程，会导致资源无法关闭
	        //t.stop();也是结束某个线程，这种方式比interrupt()更粗暴
	        t.flag = false;
	    }
	}
	class Thread2 extends Thread{
	    boolean flag = true; //用这种方式结束线程很不错，用一个变量控制run方法什么时候不再执行，不会出现run方法没有执行完毕就结束
	    @Override
	    public void run() { //run方法一结束，整个线程就终止了
	        while(flag){
	            System.out.println("---"+new Date()+"---");
	            try {
	                sleep(1000);
	            } catch (InterruptedException e) {
	                return;
	            }
	        }
	    }

}

package com.taobao.tina.test;

import java.util.Date;

/**
 * @author Tina
 *
 */
public class SleepTest {

	 public static void main(String[] args) {
	        Thread2 t = new Thread2();
	        t.start();
	        try {
	            Thread.sleep(10000); //主线程睡眠10秒钟
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	        //主线程睡眠10秒钟后结束t线程
	        //t.interrupt(); //这种结束方式比较粗暴，如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程，会导致资源无法关闭
	        //t.stop();也是结束某个线程，这种方式比interrupt()更粗暴
	        t.flag = false;
	    }
	}
	class Thread2 extends Thread{
	    boolean flag = true; //用这种方式结束线程很不错，用一个变量控制run方法什么时候不再执行，不会出现run方法没有执行完毕就结束
	    @Override
	    public void run() { //run方法一结束，整个线程就终止了
	        while(flag){
	            System.out.println("---"+new Date()+"---");
	            try {
	                sleep(1000);
	            } catch (InterruptedException e) {
	                return;
	            }
	        }
	    }

}

②join():指等待t线程终止。也可以理解为将t线程合并到当前线程来，等待t线程结束后再往下执行。相当于方法调用

package com.taobao.tina.test;

/**
 * @author Tina
 *
 */
public class TestJoin {

    public static void main(String[] args) {
        Thread t = new Thread3("abc");
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是tina线程");
            if(i==5){
                try {
                    t.join();
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Thread3 extends Thread{
    public Thread3(String s) { //给该线程取一个名字，用getName()方法可以去到该名字
        super(s);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我是"+getName()+"线程");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

运行该程序结果为：
我是main线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是tina线程
我是tina线程
我是tina线程
我是main线程
我是main线程
我是main线程
我是main线程


可以看到从第22行起就开始顺序执行了，因为i=10的时候就将该形成合并了。


　　③yield():暂停当前正在执行的线程对象，并执行其他线程。

　　④setPriority(): 更改线程的优先级。

　　　　MIN_PRIORITY = 1
　　 NORM_PRIORITY = 5
MAX_PRIORITY = 10

package com.taobao.tina.test;

/**
 * @author Tina
 * 
 */
public class YieldTest extends Thread{
	public YieldTest(){

	}
	public YieldTest(String name){
		super(name);
	}
	@Override
	public void run() {
         for(int i=0;i<=50;i++){
           System.out.println(""+this.getName()+"-----"+i);
           if(i==30){
           this.yield();
           System.out.println("I am "+this.getName()+"----"+i);//(1)
          }
	 }
	}
	public static void main(String[] args) {
	  YieldTest yt1=new YieldTest("max");  //优先级高不代表占用所有cpu时间
	  YieldTest yt2=new YieldTest("min");
          yt1.setPriority(Thread.MAX_PRIORITY); //(2)
          yt1.start();
          yt2.setPriority(Thread.MIN_PRIORITY); //(3)
          yt2.start();
	}
}

当代码中（2）（3）处都注释掉之后，yt1,yt2是一样的等级，这时候其实看不出在i=30的时候有什么区别。


没有（2）（3）条注释的情况下：多次运行会发现yt1这个进程抢cpu的技术比较高，每次都先完成。
max-----26
max-----27
max-----28
max-----29
max-----30
I am max----30
max-----31
max-----32
max-----33
max-----34

但是也有可能是yt2先执行到30，多次执行的结果我就不贴图了，因为yield()方法只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行了！

yield相对难理解一些，我在网上看到一个很形象的比喻：“就是说当一个线程使用了这个方法之后，他就把自己的cpu时间让掉，让自己或者其他的线程运行。就好像说这个线程轮到他上厕所了，然后他说“我要和大家来个竞赛'，然后所有的人在同一起跑线冲向厕所。。。。有可能是别人进去了，也有可能他自己有抢到了。我们还知道线程有个优先级的问题，那么手里有优先权的这些人就一定能抢到厕所的位置吗? 不一定的，他们只是概率上大些，也有可能没特权的抢到了。” 借此就能很好地理解yield了。


　　⑤interrupt():中断某个线程，这种结束方式比较粗暴，如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程，会导致资源无法关闭

　　要想结束进程最好的办法就是用sleep()函数的例子程序里那样，在线程类里面用以个boolean型变量来控制run()方法什么时候结束，run()方法一结束，该线程也就结束了。

　　⑥还有很多的方法就不一一列举了.........

　　

　　当然，多线程难点不在这些，多线程的难点在于多线程之间的协调。关于多线程的协调待续