java线程

Java中线程的实现
• 在Java中要想实现多线程代码有两种手段：
•一种是继承Thread类
•另一种就是实现Runnable接口

创建线程的两种方式1
1. 继承Thread类
1) 定义子类继承Thread类。
2) 子类中重写Thread类中的run方法。
3) 创建Thread子类对象,即创建了线程对象。
4) 调用线程对象start方法：启动线程,调用run方法。
 Thread类构造方法
Ø Thread()：创建新的Thread对象
Ø Thread(String threadname)：创建线程并指定线程实例名
Ø Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Ø Thread(Runnable target, String name)：创建新的Thread对象

2. 实现Runnable接口
1）定义子类,实现Runnable接口。
2）子类中重写Runnable接口中的run方法。
3）通过Thread类含参构造器创建线程对象。
4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
5）调用Thread类的start方法：开启线程,调用Runnable子类接口的run方法。

继承Thread类
• Thread类是在java.lang包中定义的,一个类只要继承
了Thread类,此类就称为多线程操作类。在Thread子
类之中,必须明确的重写Thread类中的run()方法,此
方法为线程的主体。
• 继承Thread类的多线程示例：

class MyThread extends Thread { // 继承 Thread 类
public void run(){ // 做为线程的主体
for(int x=0;x<5;x++){
System.out.println("x = " + x) ;
}
}
}

public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
...
start0();
...
}p
rivate native void start0();

 

从以上的代码中可以发现,在一个类中的start()方法调用时可能会抛出“IllegalThreadStateException”的异常,一般在重复调用start()方法的时候会抛出这个异常。而且实际上此处真正调用的是start0()方法,此方法在声明处使用了native关键字声明,此关键字表示调用本机的操作系统函数,因为多线程的实现需要依靠底层操作系统支持。

实现Runnable接口
• 在Java中也可以通过实现Runnable接口的方式实现
多线程,Runnable接口中只定义了一个抽象方法：
• public void run() ;
• 通过Runnable接口实现多线程：

class MyThread implements Runnable { // 实现Runnable接口
private String name; // 在类中定义一个属性
public MyThread(String name) { // 通过构造方法设置属性内容
this.name = name;
} public void run() {
// 重写Runnable接口中的run()方法for (int i = 0; i < 10; i++) {
System.out.println(name + "运行,i = " + i);
}
}
}

要想启动一个多线程必须要使用start()方法完成
• 但是现在实现的是Runnable接口,那么该如何启动多线
程呢？
• 实际上此时,还是要依靠Thread类完成启动,在Thread类
中提供了以下的两个构造方法：
• public Thread(Runnable target)
• public Thread(Runnable target,String name)
• 这两个构造方法都可以接收Runnable的子类实例对象。
所以就可以依靠此点启动多线程。

class MyThread2 implements Runnable { // 实现Runnable接口
private String name; // 在类中定义一个属性
public MyThread2(String name) { // 通过构造方法设置属性内容
this.name = name; // 为name属性赋值
}p
ublic void run() { // 重写Runnable接口中的run()方法
for (int i = 0; i < 10; i++) { // 循环输出10次
System.out.println(name + "运行,i = " + i);
}
}
};
public class RunnableDemo01 {
public static void main(String args[]) {
MyThread2 my1 = new MyThread2("线程一");// 实例化Runnable子类对象
MyThread2 my2 = new MyThread2("线程二");// 实例化Runnable子类对象
Thread t1 = new Thread(my1) ; // 实例化Thread类对象
Thread t2 = new Thread(my2) ; // 实例化Thread类对象
t1.start() ; // 启动线程
t2.start() ; // 启动线程
}
}

 

Thread类和Runnable接口的区别
• 实际上Thread类和Runnable接口之间在使用上也是
有所区别的
• 区别
• 继承Thread: 线程代码存放Thread子类run方法中。
• 实现Runnable：线程代码存在接口的子类的run方法。
• 实现接口方法的好处
• 1）避免了单继承的局限性
• 2）多个线程可以共享同一个接口实现类的对象,非常适合
多个相同线程来处理同一份资源。

继承Thread类不能资源共享

class Ticket extends Thread{ // 继承Thread类
private int ticket = 5 ; // 一共5张票
public void run(){ // 重写run()方法
for(int i=0;i<100;i++){ // 超出票数的循环
if(ticket>0){ // 判断是否有剩余票
System.out.println("卖票：ticket = " + ticket--) ;
}
}
}
}
public class ThreadDemo04 {
public static void main(String args[]) {
Ticket mt1 = new Ticket() ; // 定义线程对象
Ticket mt2 = new Ticket() ; // 定义线程对象
Ticket mt3 = new Ticket() ; // 定义线程对象
mt1.start() ; // 启动第一个线程
mt2.start() ; // 启动第二个线程
mt3.start() ; // 启动第三个线程
}
}

实现Runnable接口可以资源共享
 

class MyTicket implements Runnable{ // 实现Runnable接口
private int ticket = 5 ; // 一共5张票
public void run(){ // 重写run()方法
for(int i=0;i<100;i++){ // 超出票数的循环
if(ticket>0){ // 判断是否有剩余票
System.out.println("卖票：ticket=" + ticket--);
}
}
}
};
public class RunnableDemo02 {
public static void main(String args[]) {
MyTicket my = new MyTicket() ;
new Thread(my).start() ; // 启动三个线程
new Thread(my).start() ; // 启动三个线程
new Thread(my).start() ; // 启动三个线程
}
}

总结
• 可见,实现Runnable接口相对于继承Thread类来说,
有如下显著的优势：
• （1）、适合多个相同程序代码的线程去处理同一资源的
情况。
• （2）、可以避免由于Java的单继承特性带来的局限。
• （3）、增强了程序的健壮性,代码能够被多个线程共享,
代码与数据是独立的。

 

 

wait() 方法
l在当前线程中调用方法： 对象名.wait()
l使当前线程进入等待（某对象）状态 ，直到另一线程对该
对象发出 notify (或notifyAll) 为止。
l调用方法的必要条件：当前线程必须具有对该对象的监控
权（加锁）
l调用此方法后，当前线程将释放对象监控权 ，然后进入等
待
l在当前线程被notify后，要重新获得监控权，然后从断点处
继续代码的执行。

notify()/notifyAll()
l在当前线程中调用方法： 对象名.notify()
l功能：唤醒等待该对象监控权的一个线程。
l调用方法的必要条件：当前线程必须具有对该对象的监控
权（加锁）

停止线程运行
• 既然以上的三个方法不推荐使用,那么该如何停止一
个线程的执行呢？
• 在多线程的开发中可以通过设置标志位的方式停止
一个线程的运行。

class MyThread implements Runnable {
private boolean flag = true; // 定义标志位属性
public void run() { // 重写run()方法
int i = 0;
while (this.flag) { // 循环输出
while (true) {
System.out.println(Thread.currentThread().getName() + "运行
,i = " + (i++)); // 输出当前线程名称
}
}
} public void stop() {
// 编写停止方法
this.flag = false; // 修改标志位
}
} public class StopDemo {
public static void main(String[] args) {
MyThread my = new MyThread(); // 实例化Runnable接口对象
Thread t = new Thread(my, "线程"); // 建立线程对象
t.start() ; // 启动线程
my.stop() ; // 线程停止,修改标志位
}
}

定时调度

• 所谓定时调度:每当一段时间,程序自动执行
• 如果要使用定时调度,则必须保证程序始终运行才可
以,也就是说是相当于定时调度是在程序之外又启动
了一个新的线程
• Timer和TimerTask两个类完成定时调度
• Timer类是定时器要与TimerTask配合使用。
TimerTask类用来实现由Timer安排的一次或重复执
行的某一个任务。
• 每一个Timer对象对应的是一个线程,因此计时器所
执行的任务应该迅速完成,否则可能会延迟后续任务
的执行,而这些后续的任务就有可能堆在一起,等到
该任务完成后才能快速连续执行。

schedule()与scheduleAtFixedRate()方法的区别
• 两者的区别在与重复执行任务时,对于时间间隔出现
延迟的情况处理：
• schedule()方法的执行时间间隔永远是固定的,如果之前出
现了延迟的情况,之后也会继续按照设定好的的间隔时间
来执行
• scheduleAtFixedRate()方法可以根据出现的延迟时间自动
调整下一次间隔的执行时间

定时操作 —— 建立TimerTask的子类

package com.cx.demo11.task;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimerTask;
public class MyTask extends TimerTask { // 任务调度类要继承
TimerTask
public void run() {
SimpleDateFormat sdf = null;
sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
System.out.println("当前系统时间为：" + sdf.format(new
Date()));
}
}

定时操作 —— 建立测试类,进行任务调度

package com.cx.demo11.task;
import java.util.Timer;
public class TestTask {
public static void main(String[] args) {
Timer t = new Timer(); // 建立Timer类对象
MyTask mytask = new MyTask(); // 定义任务
t.schedule(mytask, 1000, 2000);//设置任务的执行1秒后开始 每2秒重复
}
}

线程池示例

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorDemo {
public static void main(String[] args) {
//创建5个固定线程
ExecutorService service=Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
final int count=i;
//线程对象
Runnable rab = new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+":"+count);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
service.submit(rab);//提交Runnable任务
} service.shutdown();
}
}