Java多线程启动方式

1.Java新建线程的方式：实现Runnable接口，或者继承Thread类。简单代码示例如下：
  实现Runnable接口

public class ThreadByRunnable implements Runnable {
	private String name;

	public ThreadByRunnable(String name) {
		this.name = name;
	}

	public void run() {
		for (int i = 0; i < 5; i++) {
			for (long k = 0; k < 100000000; k++)
				;
			System.out.println(name + ": " + i);
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ThreadByRunnable ds1 = new ThreadByRunnable("阿三");
		ThreadByRunnable ds2 = new ThreadByRunnable("李四");

		Thread t1 = new Thread(ds1);
		Thread t2 = new Thread(ds2);

		t1.start();
		t2.start();
	}
}

  继承Thread方法

public class ThreadByThread extends Thread {
	public ThreadByThread(String name) {
		super(name);
	}

	public void run() {
		for (int i = 0; i < 5; i++) {
			for (long k = 0; k < 100000000; k++)
				;
			System.out.println(this.getName() + " :" + i);
		}
	}

	public static void main(String[] args) {
		Thread t1 = new ThreadByThread("阿三");
		Thread t2 = new ThreadByThread("李四");
		t1.start();
		t2.start();
	}
}

2.线程的状态
    线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。

    对于如何干预线程的运行，最直观的方式如下（不包括在其它地方给对象加锁，从而阻碍线程的运行）。
    1).睡眠:Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
    线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。

        try {
            Thread.sleep(123);
        } catch (InterruptedException e) {
            e.printStackTrace();  
        }

    2)Thread.yield()方法
      Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。
      因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
      结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。
    3)join()方法
      Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。例如：
        Thread t = new MyThread();
       t.start();
       t.join();
示例代码：

public class JoinThread extends Thread{
     public JoinThread(String name){
           super(name);
     }
     
     public void run(){
           for(int i=0; i<10; i＋＋){
                 for(long k=0; k<100000000; k＋＋){}

                 System.out.println(this.getName() ＋ ": " ＋ i);
           }
     }
     
     public static void main(String[] args){
           Thread t1 = new JoinThread("AA AA");
           t1.start();
           try{
                 t1.join(1000);                 //Join在这里~
           } catch(InterruptedException e) {
                 e.printStackTrace();
           }      
           System.out.println("over");
     }
}

      另外，join()方法还有带超时限制的重载版本。 例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。