目录
了解进程与线程的区别
- 进程是程序的一次动态执行过程,它经历了从代码加载、执行到执行完毕的一个完整过程,这个过程也是进程本身从产生、发展到最终消亡的过程。
- 多线程是实现并发机制的一种有效手段。进程和线程一样,都是实现并发的一个基本单位。
-
掌握Java线程的两种实现方式及其区别
在Java中要想实现多线程代码有两种手段:
- 一种是继承Thread类
Thread类是在java.lang包中定义的,一个类只要继承了Thread类,此类就称为多线程操作类。在Thread子类之中,必须明确的覆写Thread类中的run()方法,此方法为线程的主体。
class 类名称 extends Thread{ // 继承Thread类
属性… ; // 类中定义属性
方法… ; // 类中定义方法
// 覆写Thread类中的run()方法,此方法是线程的主体
public void run(){
线程主体;
}
}
继承Thread类实现多线程
package com.dong1990;
public class fifth {
public static void main(String args[]) {
MyThread mt1 = new MyThread("线程A "); // 实例化对象
MyThread mt2 = new MyThread("线程B "); // 实例化对象
mt1.run(); // 调用线程主体
mt2.run(); // 调用线程主体
}
}
class MyThread extends Thread { // 继承Thread类
private String name; // 在类中定义一个属性
public MyThread(String name) { // 通过构造方法设置属性内容
this.name = name; // 为name属性赋值
}
public void run() { // 覆写Thread类中的run()方法
for (int i = 0; i < 10; i++) { // 循环10次输出
System.out.println(name + "运行,i = " + i);
}
}
}
如果要想正确的启动线程,是不能直接调用run()方法的,应该调用从Thread类中继承而来的start()方法,才可以启动线程。
mt1.start(); // 启动多线程
mt2.start(); // 启动多线程
- 一种就是实现Runnable接口
在Java中也可以通过实现Runnable接口的方式实现多线程,Runnable接口中只定义了一个抽象方法:
public void run() ;
通过Runnable接口实现多线程
class 类名称 implements Runnable{ // 实现Runnable接口
属性… ; // 类中定义属性
方法… ; // 类中定义方法
public void run(){ // 覆写Runnable接口里的run()方法 线程主体 ;
}
}
package com.dong1990;
public class fifth {
public static void main(String args[]) {
MyThread mt1 = new MyThread("线程A "); // 实例化对象
MyThread mt2 = new MyThread("线程B "); // 实例化对象
mt1.run(); // 调用线程主体
mt2.run(); // 调用线程主体
}
}
class MyThread implements Runnable { // 继承Thread类
private String name; // 在类中定义一个属性
public MyThread(String name) { // 通过构造方法设置属性内容
this.name = name; // 为name属性赋值
}
public void run() { // 覆写Thread类中的run()方法
for (int i = 0; i < 10; i++) { // 循环10次输出
System.out.println(name + "运行,i = " + i);
}
}
}
以上的代码是通过实现Runnable接口实现的多线程,但是这样一来就会有新的问题产生了,从之前的代码中可以清楚的知道,要想启动一个多线程必须要使用start()方法完成,如果继承了Thread类,则可以直接从Thread类中使用start()方法,但是现在实现的是Runnable接口,那么该如何启动多线程呢?实际上此时,还是要依靠Thread类完成启动,在Thread类中提供了以下的两个构造方法:
- public Thread(Runnable target)
- public Thread(Runnable target,String name)
这两个构造方法都可以接收Runnable的子类实例对象。所以就可以依靠此点启动多线程。
package com.dong1990;
public class fifth {
public static void main(String args[]) {
MyThread my1 = new MyThread("线程A "); // 实例化Runnable子类对象
MyThread my2 = new MyThread("线程B "); // 实例化Runnable子类对象
Thread t1 = new Thread(my1) ; // 实例化Thread类对象
Thread t2 = new Thread(my2) ; // 实例化Thread类对象
t1.start() ; // 启动线程
t2.start() ; // 启动线程
}
}
class MyThread implements Runnable { // 继承Thread类
private String name; // 在类中定义一个属性
public MyThread(String name) { // 通过构造方法设置属性内容
this.name = name; // 为name属性赋值
}
public void run() { // 覆写Thread类中的run()方法
for (int i = 0; i < 10; i++) { // 循环10次输出
System.out.println(name + "运行,i = " + i);
}
}
}
Thread类和Runnable接口的区别
实际上Thread类和Runnable接口之间在使用上也是有所区别的,如果一个类继承Thread类,则不适合于多个线程共享资源。
而实现了Runnable接口,则可以方便的实现资源的共享。
继承Thread类不能资源共享
package com.dong1990;
public class fifth {
public static void main(String args[]) {
MyThread mt1 = new MyThread("线程A") ; // 定义线程对象
MyThread mt2 = new MyThread("线程B") ; // 定义线程对象
MyThread mt3 = new MyThread("线程C") ; // 定义线程对象
mt1.start() ; // 启动第一个线程
mt2.start() ; // 启动第二个线程
mt3.start() ; // 启动第三个线程
}
}
class MyThread extends Thread { // 继承Thread类
private int ticket = 5 ; // 一共5张票
private String name; // 在类中定义一个属性
public MyThread(String name) { // 通过构造方法设置属性内容
this.name = name; // 为name属性赋值
}
public void run(){ // 覆写run()方法
for(int i=0;i<100;i++){ // 超出票数的循环
if(ticket>0){ // 判断是否有剩余票
System.out.println(name+" 卖票:ticket = " + ticket--) ;
}
}
}
}
实现Runnable接口可以资源共享
package com.dong1990;
public class fifth {
public static void main(String args[]) {
MyThread my = new MyThread("线程A") ;
new Thread(my).start() ; // 启动三个线程
new Thread(my).start() ; // 启动三个线程
new Thread(my).start() ; // 启动三个线程
}
}
class MyThread implements Runnable { // 继承Thread类
private int ticket = 5 ; // 一共5张票
private String name; // 在类中定义一个属性
public MyThread(String name) { // 通过构造方法设置属性内容
this.name = name; // 为name属性赋值
}
public void run(){ // 覆写run()方法
for(int i=0;i<100;i++){ // 超出票数的循环
if(ticket>0){ // 判断是否有剩余票
System.out.println(name+" 卖票:ticket = " + ticket--) ;
}
}
}
}
总结:
实现Runnable接口相对于继承Thread类来说,有如下显著的优势:
(1)、适合多个相同程序代码的线程去处理同一资源的情况。
(2)、可以避免由于Java的单继承特性带来的局限。
(3)、增强了程序的健壮性,代码能够被多个线程共享,代码与数据是独立的。
了解线程的操作状态
要想实现多线程,必须在主线程中创建新的线程对象。任何线程一般具有五种状态,即创建、就绪、运行、阻塞、终止。