Java进阶 ——— Java多线程(二)之如何开启多线程

引言

第一篇文章讲到了Java多线程的概念和作用,本篇文章则介绍在Java中如何开启多线程。

延伸阅读,Java多线程系列文章

Java进阶 ——— Java多线程(一)之进程和线程
Java进阶 ——— Java多线程(二)之如何开启多线程

开启方式

Java开启多线程有三种方式

继承Thread类
实现Runnable接口
java.util.concurrent.ThreadFactory 中的线程创建

继承Thread类

  • 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务。因此把run方法称为线程执行体。
  • 创建Thread子类的实例,即创建了线程对象。
  • 调用线程对象的start()方法来启动该线程。切记是调用start()方法
    示例代码:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class ThreadTest {
    private int age = 10;
    public void threadTest(){
    for (int i = 0; i < 100; i++) {
    Thread thread = new NewThread();
    thread.start();
    }
    }
    class NewThread extends Thread{
    @Override
    public void run() {
    age++;
    System.out.println(age);
    }
    }
    }

输出日志

注意
通过下列匿名内部类的方式也可以开启多线程,本质也是实现了Runnable接口,并作为参数传递给Thread类,但是不推荐这样实现,因为在Android中,例如在Activity中使用匿名内部类方式,匿名内部类会持有外部类的引用,在Activity销毁时,如果线程执行未结束,导致Activity占用内存无法释放,造成内存泄漏。

1
2
3
4
5
6
7
8
9
/**
* 避免这种方式
/
new Thread(new Runnable() {
public void run() {
//执行体
}
}).start();

实现Runnable接口

  • 定义Runnable接口的实现类,并重写该接口的run方法,该run方法的方法体同样是该线程的线程执行体
  • 创建Runnable实现类的实例对象,并以此实例对象作为Thread的target来创建Thread类,该Thread对象才是真正的线程对象。
  • 调用线程对象的start()方法来启动该线程。切记是调用start()方法
    示例代码:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class ThreadTest {
    private int age = 10;
    public void threadTest(){
    //实际的线程依然需要Thread实例对象,Thread才真正创建线程对象
    for (int i = 0; i < 100; i++) {
    Thread thread = new Thread(new ThreadRunnable());
    thread.start();
    }
    }
    class ThreadRunnable implements Runnable {
    @Override
    public void run() {
    age++;
    System.out.println(Thread.currentThread().getName() +"----"+ age); }
    }
    }

注意
Runable实现类里包含run方法,仅仅作为线程执行体,而实际的线程对象依然是Thread实例对象,Thread为真正创建线程的对象。

实现Runnable接口比继承Thread类所具有的优势:
  • 因为Java不支持多继承,但可以多实现,所以实现Runnable接口可以有效避免Java中单继承的限制。
  • 线程池只能放入实现Runable或callable类线程,不能直接放入继承Thread的类
  • Java推荐使用组合而不是继承

java.util.concurrent.ThreadFactory 中的线程创建

java.util.concurrent 包中包含一个将线程创建抽象化的ThreadFactory 接口。利用该接口,我们可以将以Runnable 作为传入参数并通过new 创建Thread 实例的处理隐藏在ThreadFactory 内部。典型用法如下所示。默认的ThreadFactory 对象是通过Executors.defaultThreadFactory 方法获取的。

示例代码:

1
2
3
4
5
6
7
8
public void threadTest(){
for (int i = 0; i < 100; i++) {
ThreadFactory factory = Executors.defaultThreadFactory();
//此处的ThradRunnable是第二种方式中实现Runnable接口的类
factory.newThread(new ThreadRunnable()).start();
}
}

总结

上面罗列了三种启动多线程的方式,包括继承Thread类,实现Runnable接口,使用ThreadFactory线程创建,推荐使用第二种,毕竟组合优于继承

感谢

http://www.cnblogs.com/albertrui/p/8376790.html

文章目录
  1. 1. 引言
  2. 2. 开启方式
    1. 2.1. 继承Thread类
    2. 2.2. 实现Runnable接口
      1. 2.2.1. 实现Runnable接口比继承Thread类所具有的优势:
    3. 2.3. java.util.concurrent.ThreadFactory 中的线程创建
  3. 3. 总结
    1. 3.1. 感谢
|