Java中关于线程的总结

java线程

1、概念与原理：

线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

2、线程工作原理

2.1主线程

一个应用程序，在启动以后，就启动了一个进程。这个进程中，默认就会有一个线程， 个线程就叫做主线程。

特点：

  1：主线程的名称叫main。

  2：获取当前线程的引用 – 》　java.lang.Thread  thread = Thread.currentThread();//通过它的静态的方法，可以获取到当前线程的引用。

public class test {
public static void main(String[] args){
//获取当前线程的引用
Thread currentThread =  Thread.currentThread();
//查看当前线程的名称、ID、优先级
System.out.println("当前线程的名称:"+currentThread.getName());
System.out.println("当前线程的Id:"+currentThread.getId());
System.out.println("当前线程的优先级:"+currentThread.getPriority());
print();
}
public static void print(){
//声明一个方法 也是获取当前的线程
Thread t = Thread.currentThread();
//获取线程名称也是main
System.out.println("name is :"+ t.getName());
}
}

运行结果：

2.2启动一个新的线程

2.2.1通过继承Thread类实现

1、创建一个Thread类的子类。

2、重建Thread类的run()方法。

3、将由子线程实现的代码写到run()里。

4、子线程也有名称，默认名称： Thread -0。

5、调用start()方法启动线程。

import java.text.SimpleDateFormat;
import java.util.Date;


public class test {
public static void main(String[] args){
//实例化线程类
OneThread one = new OneThread();
//启动线程
one.start();
//显示信息
System.out.println("这个线程启动，主线程down!");
System.out.println(Thread.currentThread().getName());
}
}
//声明一个线程类
class OneThread extends Thread{
//重写run方法
@Override
public void run() {
//要求这个线程每一秒输出一个时间
SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//死循環输出
while(true){
System.out.println(sim.format(new Date())+Thread.currentThread().getName());
//每隔一秒让线程休眠一次，调用静态方法实现Thread.sleep是静态方法，只能控制当前执行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

运行结果：

2.2.2 通过实现Runnable接口（开发中常用）

与实现Thread类相似只是书写有些偏差

import java.text.SimpleDateFormat;
import java.util.Date;


public class test {
public static void main(String[] args){
//实例化线程类
OneThread one = new OneThread();
Thread t = new Thread(one);

//启动线程
t.start();
//显示信息
System.out.println("这个线程启动，主线程down!");
System.out.println(Thread.currentThread().getName());
}
}
//声明一个线程类
class OneThread implements Runnable{
//重写run方法
public void run() {
//要求这个线程每一秒输出一个时间
SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//死循環输出
while(true){
System.out.println(sim.format(new Date())+Thread.currentThread().getName());
//每隔一秒让线程休眠一次，调用静态方法实现
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

运行截图：

2.3Thread VS  Runnable 比较

1、就是通过继承Thread类的方式时，线程类就无法继承其他的类来实现其他一些功能，实现接口的方式就没有这中限制；

2.也是最重要的一点就是，通过实现Runnable接口的方式可以达到资源共享的效果。

我们通过实现接口Runnable建立的MyThread类，而Thread类也是实现了Runnable接口的子类。如果我们想启动线程，需要通过Thread类中的start()方法，Thread类中的start()方法来调用MyThread类中run方法来执行该线程。这个实现是典型的代理模式。

注意：

在线程的Thread对象上调用start()方法，而不是run()或者别的方法。

3、线程状态的转换

一、线程状态

线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下：

1、新状态：线程对象已经创建，还没有在其上调用start()方法。

2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。

3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

4、等待/阻塞/睡眠状态：这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种，其共同点是：线程仍旧是活的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行状态。

5、死亡态：当线程的run()方法完成时就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

3、阻止线程执行

3、1睡眠

Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡眠时间到期，则返回到可运行状态

/**
 *描述：一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串
 * @author 袁意强
 *2015-1-28下午2:50:04
 */
public class MyThread extends Thread {
public void run() {
        for (int i = 0; i < 100; i++) {
            if ((i) % 10 == 0) {
                System.out.println("------------" + i);
            } 
           System.out.print(i); 
           try {
                Thread.sleep(1000); 
               System.out.print("    线程睡眠1秒！\n");
            } catch (InterruptedException e) {
                e.printStackTrace(); 
           } 
       } 
   } 
   public static void main(String[] args) {
        new MyThread().start();
    } 
}

3、2线程的优先级和线程让步yield()

线程的让步是通过Thread.yield()来实现的。yield()方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。

要理解yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。

注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

当线程池中线程都具有相同的优先级，调度程序的JVM实现自由选择它喜欢的线程。这时候调度程序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。

设置线程的优先级：线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(int newPriority)更改线程的优先级。例如：

Thread t = new MyThread();
t.setPriority(8);
t.start();

线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级。然而，1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值，而将这些优先级进行每两个或多个合并，变成少于10个的优先级，则两个或多个优先级的线程可能被映射为一个优先级。

线程默认优先级是5，Thread类中有三个常量，定义线程优先级范围：

static int MAX_PRIORITY
线程可以具有的最高优先级。
static int MIN_PRIORITY
线程可以具有的最低优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。

3、Thread.yield()方法

Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

4、join()方法

Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。例如：

Thread t = new MyThread();
t.start();
t.join();

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