黑马程序员：Java基础——多线程的概念与创建

-------
Java EE培训、java培训、期待与您交流！ ----------

1.概念

首先我们来了解下进程：进程是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

那么线程就是进程中的一个独立的控制单元，线程在控制着进程的执行。※一个进程中至少有一个线程。

Java VM启动的时候会有一个进程java.exe。该进程中至少一个负责java程序的执行，而且这个线程运行的代码存于main方法之中。该线程被称为主线程。

扩展：其实更细节说明JVM，JVM启动不止一个线程，还有负责垃圾回收机制的线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

2.线程的创建

通过对API的查找，Java已经提供了对县城这类事物的描述，就是Thread类。

创建新执行线程有两种方法。

一种方法是将类声明为 Thread 的子类。

该子类应重写

Thread

类的

run

方法。接下来可以分配并启动该子类的实例。例如，计算大于某一规定值的质数的线程可以写成：

class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
}

public void run() {
// compute primes larger than minPrime
. . .
}
}

然后，下列代码会创建并启动一个线程：

<pre class="java" name="code">PrimeThread p = new PrimeThread(143);
p.start();

每个线程都有一个标识名，多个线程可以同名。如果线程创建时没有指定标识名，就会为其生成一个新名称。

示例如下：

/**
* 创建线程的第一种方式：继承Thread类
* 步骤：
*     1.定义类继承Thead
*     2.复写Thread类中的run方法</span>
*          目的是将自定义代码存储在run方法中，让线程运行。
*     3.调用线程的start方法，该方法有两个作用：
*        1>启动线程
*        2>调用run方法
*
* */
class Demo extends Thread{
public void run(){
for(int i=0;i<60;i++){
System.out.println("Demo run!"+i);
}
}
}

public class ThreadDemo {

public static void main(String[] args) {
Demo demo = new Demo();   //创建好一个线程
demo.start();      //开启线程并执行该线程的run方法
//demo.run();       //仅仅是对象调用方法，而线程创建了，并没有运行

for(int i=0;i<60;i++){
System.out.println("Hello World!"+i);
}
}
}

运行结果如下：



从这个图可以看出：多个线程都在获取CPU的执行权。CPU执行到谁，谁就运行。需要注意的是：在某一时刻，只能有一个程序在运行。（多核除外）CPU在做着快速的切换，已达到看上去是同时运行的效果。我们可以形象的把运行行为比作在互相抢夺CPU的执行运行权。

这就是多线程的一个特性：随机性。即谁抢到谁执行，至于执行多长时间，CPU说了算。

Q&A：

Q:为什么要覆盖run方法？

A:Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。也就是说，Thread类中的run方法，用于存储线程要运行的代码。

实现Runnable接口

创建线程的另一种方法是声明实现

Runnable

接口的类。该类然后实现

run

方法。然后可以分配该类的实例，在创建

Thread

时作为一个参数来传递并启动。采用这种风格的同一个例子如下所示：

class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
}

public void run() {
// compute primes larger than minPrime
. . .
}
}

然后，下列代码会创建并启动一个线程：

PrimeRun p = new PrimeRun(143);
new Thread(p).start();

每个线程都有一个标识名，多个线程可以同名。如果线程创建时没有指定标识名，就会为其生成一个新名称。

接口 Runnable

<pre class="java" name="code">public interface Runnable

Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为

run

的无参数方法。

Runnable 为非

Thread

子类的类提供了一种激活方式。

/**
* 需求：简单的卖票程序
* 多个窗口同时卖票
*
* 创建线程的第二种方式：实现Runnable接口
*
* 步骤：
* 1.定义类实现Runnable接口
* 2.覆盖Runnable接口中的run方法
*     将线程要运行的代码存放在该run方法中
* 3.通过Thread类建立线程对象
* 4.将Runnable接口的自雷对象作为实际参数传递给Thread类的构造函数
* 5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
*
* 在定义线程时，建议使用实现方式。
* */

class Ticket implements Runnable{
private int tick=100;
public void run(){
while(true){
if(tick>0){
System.out.println(Thread.currentThread().getName()+":sale:"+tick--);
}
}
}
}

public class ThreadDemo2 {
public static void main(String[] args) {
Ticket t = new Ticket();

Thread d1 = new Thread(t);//创建一个进程
Thread d2 = new Thread(t);//创建一个进程
Thread d3 = new Thread(t);//创建一个进程
Thread d4 = new Thread(t);//创建一个进程

d1.start();
d2.start();
d3.start();
d4.start();
}
}

Q&A：

Q：为什么要将Runnable 接口的子类对象传递给Thread的构造函数?

A：因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定指定对象的run方法，就必须明确该run方法所属对象

Q:实现方式和继承方式有什么区别？

A:实现方式好处：避免了单继承的局限性。继承Thread：线程代码存放在Thread子类run方法中。实现Runnable,线程代码存放在接口的子类的run方法。如图：

线程的名称

每个线程都有一个默认的名称，例如：Thread-编号，该编号从0开始

static Thread currentThread()：获取当前线程对象。

getName()：获取线程名称

获取线程的方法可以是：Thread.currentThread().getName()方法（标准通用方式）和this.getName()方法。

设置线程名称：setName()或者构造函数

例如：

class Test extends Thread{
Test(String name){
super(name);
}
.......
}

在主函数中声明线程时传入名称：

Demo demo = new Demo("First Thread");
......

线程的运行状态

需要注意的是：当某个线程被sleep(time)后，处于冻结状态，当设定的时间超出后就会自动唤醒，进入临时状态。

而被wait()后，必须由notify()来唤醒冻结的线程。