Java多线程1：线程基础

一个线程的生命周期：

新状态：一个新产生的线程从新状态开始了它的生命周期。它保持这个状态知道程序start这个线程。

运行状态：当一个新状态的线程被start以后，线程就变成可运行状态，一个线程在此状态下被认为是开始执行其任务。

就绪状态：当一个线程等待另外一个线程执行一个任务的时候，该线程就进入就绪状态。当另一个线程给就绪状态的线程发送信号时，该线程才重新切换到运行状态。

休眠状态：由于一个线程的时间片用完了，该线程从运行状态进入休眠状态。当时间间隔到期或者等待的时间发生了，该状态的线程切换到运行状态。

终止状态：一个运行状态的线程完成任务或者其他终止条件发生，该线程就切换到终止状态。

每当我们用java命令运行一个类时，实际上就会启动一个JVM，而每个JVM在操作系统中就是一个进程。一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守候线程都结束运行后才能结束。在该类中启动的每个线程都存在于该进程中。而每次运行时至少启动2个线程，一个是main线程，一个是垃圾回收线程。

创建一个线程：

继承Thread类：

public class TestThread extends Thread {
	private String name;
	public TestThread(String name) {
		this.name = name;
	}
	public void run() {
		for (int i = 0; i < 500; i++) {
			System.out.println(name + ":" + i);
		}
	}
	public static void main(String[] args) {
		TestThread t1 = new TestThread("A");
		TestThread t2 = new TestThread("B");
		t1.start();
		t2.start();
	}
}

我们调用了start方法，而没有直接调用run方法，原因是start会调用本地操作系统的函数。下面是start的源码：

public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            
        }
    }
}
private native void start0();

start0使用了native关键字，正面是调用了系统的函数。start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

实现Runnable接口：

public class TestRunnable implements Runnable {
	private String name;
	public TestRunnable(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		for (int i = 0; i < 500; i++) {
			System.out.println(name + ":" + i);
		}
	}
	public static void main(String[] args) {
		TestRunnable r1 = new TestRunnable("C");
		Thread t1 = new Thread(r1);
		TestRunnable r2 = new TestRunnable("D");
		Thread t2 = new Thread(r2);
		t1.start();
		t2.start();
	}
}

实现Runnable接口比继承Thread类所具有的优势：

1.适合多个相同的程序代码的线程去处理同一个资源

2.可以避免java中的单继承的限制

3.增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

资源共享demo：

public class TicketManager() {
	public static void main(String[] args) {
		TicketWindow tw = new TicketWindow();
		Thread t1 = new Thread(tw, "win1");
		Thread t2 = new Thread(tw, "win2");
		Thread t3 = new Thread(tw, "win3");
	}
}
class TicketWindow() implements Runnable() {
	private int ticket = 500;

	@Override
	public void run() {
		for(int i = 0; i < 1000; i ++) {
			if(this.ticket > 0) {
				System.out.println(Thread.currentThread().getName() + " sell ticket number is " + this.ticket--);
			}
		}
	}
}

demo模拟一个售票大厅，窗口win1、win2、win3都卖同一种票ticket。我们用三个线程模拟3个窗口，共享资源ticket在类TicketWindow中。实现Runnable更容实现资源的共享。

线程的优先级：

每一个Java线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。Java优先级在MIN_PRIORITY(1)和MAX_PRIORITY(10)之间的范围内。默认情况下，每一个线程都会分配一个优先级NORM_PRIORITY(5)。

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器时间。然而，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

Thread方法：

下表列出了Thread类的一些重要方法：

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

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

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