Java多线程之创建任务和线程

Runnable创建线程

任务就是对象。为了创建任务，必须首先为任务定义一个类。任务类必须实现Runnable接口。Runnable接口非常简单，它只包含一个run方法。需要实现这个方法来告诉系统线程将如何运行。开发一个任务类的模板如图29-2a所示。

一旦定义了一个TaskClass,就可以用它的构造方法创建一个任务。例如，

TaskClass task = new TaskClass(...);

任务必须在线程中执行。Thread类包括创建线程的构造方法以及控制线程的很多有用的方法。使用下面的语句创建任务的线程：

Thread thread = new Thread(task);

然后调用start()方法告诉Java虚拟机该线程准备运行，如下所示：

thread.start();

Java虚拟机通过任务的run()方法执行任务。图29-2b概括了创建一个任务，一个线程以及开始线程的主要步骤。



下面例子给出一个程序，它创建三个任务以及运行这三个任务的线程：

第一个任务打印字母a100次

第二个任务打印字母b100次

第三个任务打印1~100的整数。

如果运行这个程序，则三个线程将共享CPU，并且在控制台上轮流打印字母和数字。

package chapter29;

public class TaskThreadDemo
{
public static void main(String[] args)
{
//Create tasks
Runnable printA = new PrintChar('a',100);
Runnable printB = new PrintChar('b',100);
Runnable print100 = new PrintNum(100);

//Create threads
Thread thread1 = new Thread(printA);
Thread thread2 = new Thread(printB);
Thread thread3 = new Thread(print100);

//Start threads
thread1.start();
thread2.start();
thread3.start();
}
}

//The task for printing a character a specified number of times
class PrintChar implements Runnable
{
private char charToPrint;//The character to print
private int times;//The number of times to repeat

/*
* Construct a task with specified character to print
* times to print the character
*/
public PrintChar(char c,int t)
{
charToPrint = c;
times = t;
}

/*
* Override the run() method to tell the system
* what task to perform
*/
public void run()
{
for(int i = 0; i < times; i++)
{
System.out.println(charToPrint);
}
}
}

//The task class for printing numbers from 1 to n for a given n
class PrintNum implements Runnable
{
private int lastNum;

/*Construct a task for printing 1,2,.....n*/
public PrintNum(int n)
{
lastNum = n;
}

/*Tell the thread how to run*/
public void run()
{
for(int i = 1; i <= lastNum; i++)
{
System.out.println(" " + i);
}
}
}

该程序创建了三个任务。为了同时运行它们，创建三个线程。调用start()方法启动一个线程，它会导致任务中的run()方法被执行。当run()方法执行完毕，线程就终止。

因为前两个任务printA和printB有类似的功能，所以它们可以定义在同一个任务类PrintChar中。PrintChar类实现Runnable，并且覆盖run()方法，使之具备打印字符动作。该类提供根据给定次数打印任意单个字符的框架。可运行对象printA和printB都是PrintChar类的实例。

PrintNum类实现Runnable，并且覆盖run()方法，使之具备打印数字的动作。该类提供对于任意整数n，打印从

1到n的整数的框架。可运行对象print100是PrintNum类的一个实例。

注意:如果看不到并发运行三个线程的效果，那么就要增加打印字符的个数。例如：

Runnable printA = new PrintChar('a',10000);

package heima;

/*
* 需求:简单的卖票程序
* 多个窗口同时买票
*
* 创建线程的第二种方式：实现Runnable接口
*
* 步骤:
* 1.定义类实现Runnable接口
* 2.覆盖Runnable接口中的run方法。
*   将线程要运行的代码存放在该run方法中。
* 3.通过Thread类建立线程对象。
* 4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
*   为什么要将Runnable接口的子类对象传递给Thread的构造函数。
*   因为：自定义的run方法所属的对象是Runnable接口的子类对象
*   所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
* 5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
*
* 实现方式和继承方式有什么区别呢?
*
* 实现方式好处:避免了单继承的局限性。
* 在定义线程时，建议使用实现方式。
*
* 两种方式区别:
* 继承Thread:线程代码存放Thread子类run方法中
* 实现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 TicketThread
{
public static void main(String[] args)
{
Ticket t = new Ticket();

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
/*Ticket t1 = new Ticket();
Ticket t2 = new Ticket();
Ticket t3 = new Ticket();
Ticket t4 = new Ticket();

t1.start();
t2.start();
t3.start();
t4.start();*/
}
}

创建线程的另一种方法:Thread类

Thread类包含为任务而创建的线程的构造方法，以控制线程的方法。

步骤:
1.定义类继承Thread，
2.复写Thread类中的run方法，
目的:将自定义代码存储在run方法。让线程运行。
3.调用线程的start方法，
该方法两个作用：启动线程，调用run方法
发现运行结果每一次都不同，
因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行。明确一点，在某一时刻，只能有一个程序在运行，（多核除外）
cpu在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象把多线程的运行认为在互相抢夺cpu的执行权。

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

为什么要覆盖run方法呢?
Thread类用于描述线程
该类定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法

也就是说Thread类中的run方法，用于存储线程要运行的代码。

class Demo extends Thread
{
public void run()
{
for(int x = 0; x < 60; x++)
{
System.out.println("demo run----"+x);
}
}
}

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

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

/*
练习:
创建两个线程，和主线程交替运行。
*/
class Test extends Thread
{
private String name;
Test(String name)
{
this.name = name;
}
public void run()
{
for (int x = 0; x < 60; x++)
{
System.out.println(name + " run..." + x);
}
}
}

public class ThreadTest
{
public static void main(String[] args)
{
Test t1 = new Test("one");
Test t2 = new Test("two");
t1.start();
t2.start();
//t1.run();
//t2.run();

for(int x = 0; x < 60; x++)
{
System.out.println("main......" + x);
}
}
}

线程的运行状态

获取线程对象及名称

package heima;

/*
* 原来线程都有自己默认的名称
* Thread-编号 该编号从0开始。
*
* static Thread currentThread():获取当前线程对象。
* getName():获取线程名称
*
* 设置线程名称：setName或者构造函数。
*/
class Test extends Thread
{
private String name;
Test(String name)
{
this.name = name;
}
public void run()
{
for (int x = 0; x < 60; x++)
{
System.out.println((Thread.currentThread() == this) + "..." + this.getName() + " run..." + x);
}
}
}

public class ThreadTest
{
public static void main(String[] args)
{
Test t1 = new Test("one");
Test t2 = new Test("two");
t1.start();
t2.start();
//t1.run();
//t2.run();

for(int x = 0; x < 60; x++)
{
System.out.println("main......" + x);
}
}
}