【Java学习笔记】线程

------Java培训、Android培训、iOS培训、.Net培训 期待与您交流！-------

今天查看API学习了线程的概念还有用法。

public class Thread
extends Object
implements Runnable
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to have multiple threads of execution running concurrently.
Every thread has a priority. Threads with higher priority are executed in preference to threads with lower priority. Each thread may or may not also be marked as a daemon. When code running in some thread creates a new Thread object, the new thread has its priority initially set equal to the priority of the creating thread, and is a daemon thread if and only if the creating thread is a daemon.

When a Java Virtual Machine starts up, there is usually a single non-daemon thread (which typically calls the method named main of some designated class). The Java Virtual Machine continues to execute threads until either of the following occurs:
The exit method of class Runtime has been called and the security manager has permitted the exit operation to take place.
All threads that are not daemon threads have died, either by returning from the call to the run method or by throwing an exception that propagates beyond the run method.
There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread. This subclass should override the run method of class Thread. An instance of the subclass can then be allocated and started.The other way to create a thread is to declare a class that implements the Runnable interface. That class then implements the run method. An instance of the class can then be allocated, passed as an argument when creating Thread, and started. 

公共类Thread继承自对象类，实现了Runable接口。

线程是程序中执行的一个进程。Java虚拟机允许一个应用中有多个线程并行执行。

每一个线程都有优先级。高优先级的线程会先被执行。每一个线程都有可能被标记为守护线程。当在线程内运行代码时会创建一个新的线程对象，新的线程将拥有和被创建的线程同等的优先级，并且当且仅一个线程创建的线程是守护线程时，那么这个线程才是守护线程。

在Java虚拟机启动的时候，通常都会有一个非单一的守护线程(一般调用指定类的方法)。Java虚拟机会继续执行线程，直到出现以下情况：

1>Runtime类的退出方法被调用，并且安全管理器运行退出操作被执行时

2>无论是从调用run方法中返回的，或是超出run方法而抛出的异常而产生的所有非守护线程都已经结束。

有两种方法可以创建一个新的线程。一是声明一个Thread类的子类。这个子类要重写Thread类的run方法。实例化的子类可以被分配和启动。另一个方法是声明一个实现Runnable接口的类，然后让该类实现run方法。实例化的子类可以被分配，作为参数传递，启动。

下面是简单实例：

package exp;

/**
 * 线程简单实例
 * 
 * @author VisionDo
 *
 */
public class ThreadDemo {

	public static void main(String[] args) {
		MyThread myth = new MyThread();
		MyThread2 myth2 = new MyThread2();
		
		Thread th = new Thread(myth);//创建线程
		th.start();//启动线程
		
		th = new Thread(myth2);//创建线程
		th.start();//启动线程
		
	}

}


/**
 * 
 * 通过继承Thread，重写run方法得到线程
 *
 */
class MyThread extends Thread{

	@Override
	public void run() {
		super.run();
		String s = "通过继承Thread，重写run方法生成线程";
		System.out.println(s);
	}
		
}

/**
 * 
 * 通过实现Runnable接口，重写run方法得到线程
 *
 */
class MyThread2 implements Runnable{

	@Override
	public void run() {
		String s = "通过实现Runnable接口，重写run方法生成线程";
		System.out.println(s);
	}
	
}

运行后输出：

可以看出，run方法内的语句都被打印出来了。执行顺序与线程的start方法一致。