Java 学习（五）—— 线程

一、线程的基本概念

1.线程是一个程序内部的顺序控制流。

2.线程和进程的区别

① 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会消耗比较大的开销。例如，手机中的app进程；

② 线程是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换开销小；

③ 多进程：操作系统中同时运行多个任务（程序）；

④ 多线程：在同一应用程序中有多个顺序流同时执行；

一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守候线程都结束运行后才能结束。

3.线程的生命周期

新建状态: 一个新产生的线程从新状态开始了它的生命周期。它保持这个状态直到程序start这个线程。
运行状态:当一个新状态的线程被start以后，线程就变成可运行状态，一个线程在此状态下被认为是开始执行其任务
就绪状态:当一个线程等待另外一个线程执行一个任务的时候，该线程就进入就绪状态。当另一个线程给就绪状态的线程发送信号时，该线程才重新切换到运行状态。
休眠状态: 由于一个线程的时间片用完了，该线程从运行状态进入休眠状态。当时间间隔到期或者等待的事件发生了，该状态的线程切换到运行状态。
终止状态: 一个运行状态的线程完成任务或者其他终止条件发生，该线程就切换到终止状态。

4.Java中的线程

① Java的线程通过 java.lang.Thread 类来实现；

② VM启动时，会有一个由主方法（public static void main(){}）所定义的线程；

③ 通过创建 Thread 实例来创建新的线程；

④ 每个线程都是通过某个特定的 Thread 对象所对应的方法 run() 来完成某操作，方法 run () 称为线程体；

⑤ 通过调用 Thread 类的 start() 方法来启动线程；

线程理解：线程是一个程序里面不同的执行路径；

每一个分支都叫做一个线程，main()叫做主分支，也叫主线程。

　　程只是一个静态的概念，机器上的一个.class文件，机器上的一个.exe文件，这个叫做一个进程。程序的执行过程都是这样的：首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始，进程已经产生了，但还没有开始执行，这就是进程，所以进程其实是一个静态的概念，它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了，也就是main()方法开始执行了。进程是一个静态的概念，在我们机器里面实际上运行的都是线程。

　　Windows操作系统是支持多线程的，它可以同时执行很多个线程，也支持多进程，因此Windows操作系统是支持多线程多进程的操作系统。Linux和Uinux也是支持多线程和多进程的操作系统。DOS就不是支持多线程和多进程了，它只支持单进程，在同一个时间点只能有一个进程在执行，这就叫单线程。

　　CPU难道真的很神通广大，能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。

学习线程首先要理清楚三个概念：

进程：进程是一个静态的概念
线程：一个进程里面有一个主线程叫main()方法，是一个程序里面的，一个进程里面不同的执行路径。
在同一个时间点上，一个CPU只能支持一个线程在执行。因为CPU运行的速度很快，因此我们看起来的感觉就像是多线程一样。

　　什么才是真正的多线程？如果你的机器是双CPU，或者是双核，这确确实实是多线程。

二、线程的创建和启动

Java提供了两种创建线程方法：

通过实现Runnable接口；
通过继承Thread类本身。

1.通过实现Runnable接口来创建线程

① 开辟一个新的线程来调用run方法

package thread;

public class TestThread1 {

	public static void main(String[] args) {
		Runner1 r1 = new Runner1();		//这里new了一个线程类的对象出来
		//r1.run();				//这个称为方法调用，方法调用的执行是等run()方法执行完之后才会继续执行main()方法
		Thread t = new Thread(r1);		//要启动一个新的线程就必须new一个Thread对象出来
							//这里使用的是Thread(Runnable target) 这构造方法
		t.start();				//启动新开辟的线程，新线程执行的是run()方法，新线程与主线程会一起并行执行
		for (int i = 0; i < 5; i++) {
			System.out.println("mainthread:"+i);
		}
	}
}

/*定义一个类用来实现Runnable接口，实现Runnable接口就表示这个类是一个线程类*/
class Runner1 implements Runnable{
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println("Runner1:"+i);
		}
	}
}

多线程程序执行结果：

mainthread:0
Runner1:0
mainthread:1
Runner1:1
mainthread:2
Runner1:2
mainthread:3
Runner1:3
mainthread:4
Runner1:4

② 不开辟新线程直接调用run方法

程序执行结果：

Runner1:0
Runner1:1
Runner1:2
Runner1:3
Runner1:4
mainthread:0
mainthread:1
mainthread:2
mainthread:3
mainthread:4

2.通过实现Thread接口来创建线程

创建一个线程的第二种方法是创建一个新的类，该类继承Thread类，然后创建一个该类的实例。

继承类必须重写run()方法，该方法是新线程的入口点。它也必须调用start()方法才能执行。

package thread;

/**
 * 定义Thread的子类并实现run()方法
 * @author 98736
 *
 */
public class TestThread2 {
	public static void main(String[] args) {
		Runner2 r2 = new Runner2();
		r2.start();			//调用start()方法启动新开辟的线程
		for (int i = 0; i < 5; i++) {
			System.out.println("mainMethod:"+i);
		}
	}
}

/*Runner2类从Thread类继承
通过实例化Runner2类的一个对象就可以开辟一个新的线程
调用从Thread类继承来的start()方法就可以启动新开辟的线程*/
class Runner2 extends Thread{
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println("Runner2:"+i);
		}
	}	
}

三、线程控制的基本方法

方法	描述
public void start()	使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
public void run()	如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
public final void setName(String name)	改变线程名称，使之与参数 name 相同。
public final void setPriority(int priority)	更改线程的优先级。
public final void setDaemon(boolean on)	将该线程标记为守护线程或用户线程。
public final void join(long millisec)	等待该线程终止的时间最长为 millis 毫秒。
public final boolean isAlive()	测试线程是否处于活动状态。

测试线程是否处于活动状态。上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法

方法	描述
public static void yield()	暂停当前正在执行的线程对象，并执行其他线程。
public static void sleep(long millisec)	在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
public static boolean holdsLock(Object x)	当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
public static Thread currentThread()	返回对当前正在执行的线程对象的引用。
public static void dumpStack()	将当前线程的堆栈跟踪打印至标准错误流。

四、sleep、join、yield 方法介绍

① sleep方法的应用范例：

package thread;

import java.util.*;

public class TestThreadSleep {
	public static void main(String args[]) {
		MyThread thread = new MyThread();
		thread.start();// 调用start()方法启动新开辟的线程
		try {
			/*
			 * Thread.sleep(10000);
			 * sleep()方法是在Thread类里面声明的一个静态方法，因此可以使用Thread.sleep()的格式进行调用
			 */
			/*
			 * MyThread.sleep(10000);
			 * MyThread类继承了Thread类，自然也继承了sleep()方法，所以也可以使用MyThread.sleep()的格式进行调用
			 */
			/*
			 * 静态方法的调用可以直接使用“类名.静态方法名” 或者“对象的引用.静态方法名”的方式来调用
			 */
			MyThread.sleep(10000);
			System.out.println("主线程睡眠了10秒种后再次启动了");
			// 在main()方法里面调用另外一个类的静态方法时，需要使用“静态方法所在的类.静态方法名”这种方式来调用
			/*
			 * 所以这里是让主线程睡眠10秒种 在哪个线程里面调用了sleep()方法就让哪个线程睡眠，所以现在是主线程睡眠了。
			 */
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		// thread.interrupt();//使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
		thread.flag = false;// 改变循环条件，结束死循环
		/**
		 * 当发生InterruptedException时，直接把循环的条件设置为false即可退出死循环，
		 * 继而结束掉子线程的执行，这是一种比较好的结束子线程的做法
		 */
		/**
		 * 调用interrupt()方法把正在运行的线程打断 相当于是主线程一盆凉水泼上去把正在执行分线程打断了
		 * 分线程被打断之后就会抛InterruptedException异常，这样就会执行return语句返回，结束掉线程的执行
		 * 所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
		 */
	}
}

class MyThread extends Thread {
	boolean flag = true;// 定义一个标记，用来控制循环的条件

	public void run() {
		/*
		 * 注意：这里不能在run()方法的后面直接写throw Exception来抛异常，
		 * 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。 所以这里只能写try……catch()来捕获异常
		 */
		while (flag) {
			System.out.println("==========" + new Date().toLocaleString() + "===========");
			try {
				/*
				 * 静态方法的调用格式一般为“类名.方法名”的格式去调用 在本类中声明的静态方法时调用时直接写静态方法名即可。
				 * 当然使用“类名.方法名”的格式去调用也是没有错的
				 */
				// MyThread.sleep(1000);//使用“类名.方法名”的格式去调用属于本类的静态方法
				sleep(1000);// 睡眠的时如果被打断就会抛出InterruptedException异常
				// 这里是让这个新开辟的线程每隔一秒睡眠一次，然后睡眠一秒钟后再次启动该线程
				// 这里在一个死循环里面每隔一秒启动一次线程，每个一秒打印出当前的系统时间
			} catch (InterruptedException e) {
				/*
				 * 睡眠的时一盘冷水泼过来就有可能会打断睡眠
				 * 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
				 */
				return;
				// 线程被中断后就返回，相当于是结束线程
			}
		}
	}
}

程序运行结果：

==========2018-5-25 17:34:34===========
==========2018-5-25 17:34:35===========
==========2018-5-25 17:34:36===========
==========2018-5-25 17:34:37===========
==========2018-5-25 17:34:38===========
==========2018-5-25 17:34:39===========
==========2018-5-25 17:34:40===========
==========2018-5-25 17:34:41===========
==========2018-5-25 17:34:42===========
==========2018-5-25 17:34:43===========
主线程睡眠了10秒种后再次启动了

② join方法的应用范例：

package thread;

public class TestThreadJoin {
	public static void main(String args[]) {
        MyThread2 thread2 = new MyThread2("mythread");
        // 在创建一个新的线程对象的同时给这个线程对象命名为mythread
        thread2.start();// 启动线程
        try {
            thread2.join();// 调用join()方法合并线程，将子线程mythread合并到主线程里面
            // 合并线程后，程序的执行的过程就相当于是方法的调用的执行过程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am main Thread");
        }
    }
}

class MyThread2 extends Thread {
    MyThread2(String s) {
        super(s);
        /*
         * 使用super关键字调用父类的构造方法 
         * 父类Thread的其中一个构造方法：“public Thread(String name)” 
         * 通过这样的构造方法可以给新开辟的线程命名，便于管理线程
         */
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("I am a\t" + getName());
            // 使用父类Thread里面定义的
            //public final String getName()，Returns this thread's name.
            try {
                sleep(1000);// 让子线程每执行一次就睡眠1秒钟
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

程序运行结果：

I am a	mythread
I am a	mythread
I am a	mythread
I am a	mythread
I am a	mythread
I am main Thread
I am main Thread
I am main Thread
I am main Thread
I am main Thread
I am main Thread

③ yield方法的应用范例：

package thread;

public class TestThreadYield {
	public static void main(String args[]) {
		MyThread3 t1 = new MyThread3("t1");
		/* 同时开辟了两条子线程t1和t2，t1和t2执行的都是run()方法 */
		/* 这个程序的执行过程中总共有3个线程在并行执行，分别为子线程t1和t2以及主线程 */
		MyThread3 t2 = new MyThread3("t2");
		t1.start();// 启动子线程t1
		t2.start();// 启动子线程t2
		for (int i = 0; i <= 5; i++) {
			System.out.println("I am main Thread");
		}
	}
}
class MyThread3 extends Thread {
    MyThread3(String s) {
        super(s);
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(getName() + "：" + i);
            if (i % 2 == 0) {
                yield();// 当执行到i能被2整除时当前执行的线程就让出来让另一个在执行run()方法的线程来优先执行
                /*
                 * 在程序的运行的过程中可以看到，
                 * 线程t1执行到(i%2==0)次时就会让出线程让t2线程来优先执行 
                 * 而线程t2执行到(i%2==0)次时也会让出线程给t1线程优先执行
                 */
            }
        }
    }
}

程序运行结果：

I am main Thread
I am main Thread
I am main Thread
I am main Thread
I am main Thread
I am main Thread
t2：1
t2：2
t1：1
t1：2
t2：3
t1：3
t2：4
t1：4
t2：5
t1：5

文章参考：孤傲苍狼