java线程:概念与原理
一、操作系统中线程和进程的概念
现在的操作系统是多任务的操作系统，多线程是多任务的一种实现方式。
进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程可以启动多个线程。比如，在Windows系统中，一个运行的exe就是一个进程。
线程是指进程中的一个执行流程，一个进程可以运行多个线程。比如，java.exe进程中可以运行多个线程，线程总属于某个进程，进程中的多个线程共享进程的内存。
二、Java中的线程
在Java中，“线程”指两个不同的事情：
- java.lang.Thread类的一个实例
- 线程的执行
使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义，实例化和启动线程。
一个Thread类实力只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。
Java中每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。
一个Java应用总是从main()方法开始运行,main()方法运行在一个线程里，称为主线程。
一旦创建一个新线程，就产生一个新的调用栈。
线程总体分为两类：用户线程和守护线程。
当所有用户线程执行完毕，JVM自动关闭。但守护线程却不独立于JVM，守护线程一般由操作系统或者用户自己创建。
Java线程：创建与启动
一、定义线程
1.扩展java.lang.Thread类
此类中有个run()方法，应该注意其用法：
public void run()
如果该线程是使用独立的Runnable运行对象构造的，则调用该Runnable对象的run方法；否则该方法不执行任何操作并返回。
Thread的子类应该重写该方法。
2.实现java.lang.Runnable接口
void run()
使用实现Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run()方法。
二、实例化线程
1.扩展java.lang.Runnable类的线程,直接new即可
例：
public class MyThread extends Thread {
private int i = 0;
@Override
public void run() {
// TODO Auto-generated method stub
for (i = 0; i < 100; i++) {
System.out.println(MyThread.currentThread().getName() + " " + i);
}
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
if (i == 30) {
Thread myThread1 = new MyThread(); // 创建一个新的线程 myThread1 此线程进入新建状态
Thread myThread2 = new MyThread(); // 创建一个新的线程 myThread2 此线程进入新建状态
myThread1.start(); // 调用start()方法使得线程进入就绪状态
myThread2.start(); // 调用start()方法使得线程进入就绪状态
}
}
}
}
2. 如果是实现了java.lang.Runnable接口的类,则用Thread的构造方法
Thread(Runnable target)
例：
public class MyRunnable implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("MyRunnable run");
for(int i=0;i<100;i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
if (i == 30) {
Runnable myrunable = new MyRunnable();
Thread mythread = new MyThread(myrunable);
mythread.start();
}
}
}
}
三、启动线程
在线程的thread对象上调用start()方法，而不是run()方法或其他方法。
在调用start()方法后：
启动新的线程（具有新的调用栈）
该线程从新建状态转移到就绪状态，等待CPU执行
当该线程执行时，其run()方法将运行
注意：对Java来说，run()方法没有任何特别之处。像main()方法一样，它只是新线程知道调用的方法名称(和签名)。因此，在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。
五、常见的问题
1、线程的名字，一个运行中的线程总是有名字的，名字有两个来源，一个是虚拟机给自己的名字，一个是自己定的名字。在没有指定线程名字的情况下，虚拟机总会为线程指定名字，且主线程的名字总是main，非主线程的名字不确定。
2、线程都可以设定名字，也可以获取线程的名字。
3、获取当前线程的对象的方法：Thread.currentThread()。
4、对于任何一组启动的线程来说,调度程序不能保证其执行顺序，持续时间也无法保证。
5、当线程的目标run()方法结束时，该线程完成。
6、一旦线程启动，永远不能重启，只有一个新线程可以被启动，且只能一次。一个可运行的线程或死线程可以被重新启动。
7、线程的调度是JVM的一部分，在一个CPU的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。
众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。
Java线程：线程栈模型与线程的变量
要理解县城的调度原理,以及线程的执行过程,必须理解线程栈模型。
线程栈：是指某时刻时，内存中线程调度的栈信息，当前调用的方法总是位于栈顶。线程栈的内容是随着程序运行动态变化的，因此研究线程栈必须选择某一运行时刻（实际上指代码运行到什么地方）
例：线程（调用）栈的变化过程。
这幅图描述在代码执行到两个不同时刻1、2时候，虚拟机线程调用栈示意图.
当程序执行到t.start();时候，程序多出一个分支（增加了一个调用栈B），这样，栈A、栈B并行执行.
从这里就可以看出方法调用和线程启动的区别了。
Java线程：线程状态的转换
一、线程的状态
线程的状态转换是线程的基础，现成的状态总体可分为五大状态：
- 新建状态（New）：当线程对象对创建后，即进入了新建状态，
如：Thread t = new MyThread();- 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。
处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；- 执行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。
注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中。
- 阻塞状态（Blocked)：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。
- 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
二、阻塞的三种情况
1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
睡眠
Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行）以“减慢线程”。
线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。
睡眠的实现:
调用静态方法sleep()
try{
Thread.sleep(1);
}catch((InterruptedException e) {
e.printStackTrace();
}
为了让其他线程有机会执行，可以将Thread.sleep()的调用放在线程run()之内，这样才能保证线程在执行过程中会睡眠。
注意：
- 线程睡眠是帮助所有线程获得运行机会的最好方法。
- 线程睡眠到期自动苏醒，并返回就绪状态，不是运行状态。sleep()方法并不能保证该线程睡眠到期后立即执行。
- sleep()是静态方法，只能控制当前正在运行的线程。
线程的优先级和线程让步yield()
线程的让步是通过Thread.yield()方法来实现的。yield方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。
要理解yield(），必须了解线程的优先级的概念。
线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程的优先级大于或等于线程池中任何线程的优先级。
注意：当设计多线程应用程序，一定不要依赖于线程的优先级，因为线程的优先级操作是没有保证的，只能把线程的优先级作为提高程序效率的方法，但不要依赖这种操作。
设置线程的优先级：线程默认的优先级是创建他的执行线程的优先级，可通过setPriority(int newPriority)更改线程的优先级。
Thread t = new MyThread();
t.setPriority(8);
t.start();
yield()应该做的是让当前运行线程回到就绪状态，以允许具有相同优先级的其他线程获得运行机会。
因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
join()方法
Thread的非静态方法join（）让一个线程B“加入”到另一个线程A的尾部。在A执行完毕前，B不能工作。例如：
Thread t = new MyThread();
t.start();
t.join();
另外，join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。
小结
到目前为止，线程离开运行状态的3种方法：
1、调用Thread.sleep():使线程睡眠至少多少毫秒；
2、调用Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。
3、调用join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。
除了以上三种方式外，还有下面几种特殊情况可能使线程离开运行状态：
1、线程的run()方法完成。
2、在对象上调用wait()方法（不是在线程上调用）。
3、线程不能在对象上获得锁定，它正试图运行该对象的方法代码。
4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便让另一个线程获得运行机会，而不需要任何理由。
内容转载自：http://blog.csdn.net/shimiso