java 线程

java多线程的3种方式

实现多线程的3种方式

 

1、继承Thread类

 

看jdk源码可以发现，Thread类其实是实现了Runnable接口的一个实例，继承Thread类后需要重写run方法并通过start方法启动线程。

 

继承Thread类耦合性太强了，因为java只能单继承，所以不利于扩展。

 

2、实现Runnable接口

 

通过实现Runnable接口并重写run方法，并把Runnable实例传给Thread对象，Thread的start方法调用run方法再通过调用Runnable实例的run方法启动线程。

 

所以如果一个类继承了另外一个父类，此时要实现多线程就不能通过继承Thread的类实现。

 

3、实现Callable接口

 

通过实现Callable接口并重写call方法，并把Callable实例传给FutureTask对象，再把FutureTask对象传给Thread对象。它与Thread、Runnable最大的不同是Callable能返回一个异步处理的结果Future对象并能抛出异常，而其他两种不能。

 

示例代码

 

 

结果输出：

 

Thread1 running...

Thread2 running...

Thread3 running...

name:java,age:22

 

Java多线程分组

来看下线程类 Thread 的所有构造方法。

 

如图所示，带有 ThreadGroup 的所有线程构造方法都可以定义线程组的。

线程组使用 java.lang.ThreadGroup 类定义，它有两个构造方法，第二个构造方法允许线程组有父类线程组，也就是说一个线程组可以多个子线程组。

java.lang.ThreadGroup#ThreadGroup(java.lang.String)
java.lang.ThreadGroup#ThreadGroup(java.lang.ThreadGroup, java.lang.String)

 

 

 

 

线程组中比较有用的几个方法。

// 获取当前线程组内的运行线程数
java.lang.ThreadGroup#activeCount

 

// 中断线程组内的所有线程
java.lang.ThreadGroup#interrupt

 

// 使用 System.out 打印出所有线程信息
java.lang.ThreadGroup#list()

我们来简单使用下线程组吧！

/**
 * 微信公众号：Java技术栈
 */
public static void main(String[] args) {
    Runnable runnable = () -> {
        System.out.println("Java技术栈线程线程组名称：" + Thread.currentThread().getThreadGroup());
        System.out.println("Java技术栈线程线程名称：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    };

    ThreadGroup userGroup = new ThreadGroup("user");
    userGroup.setMaxPriority(Thread.MIN_PRIORITY);

    Thread userTask1 = new Thread(userGroup, runnable, "user-task1");
    Thread userTask2 = new Thread(userGroup, runnable, "user-task2");

    userTask1.start();
    userTask2.start();

    System.out.println("Java技术栈线程线程组活跃线程数：" + userGroup.activeCount());
    userGroup.list();

}

程序输出以下结果。

Java技术栈线程线程组名称：java.lang.ThreadGroup[name=user,maxpri=1]
Java技术栈线程线程名称：user-task1
Java技术栈线程线程组活跃线程数：2
Java技术栈线程线程组名称：java.lang.ThreadGroup[name=user,maxpri=1]
Java技术栈线程线程名称：user-task2
java.lang.ThreadGroup[name=user,maxpri=1]
    Thread[user-task1,1,user]
    Thread[user-task2,1,user]

根据示例代码和程序输出结果应该对线程组有了一个大概的了解吧。

线程组还能统一设置组内所有线程的最高优先级，线程单独设置的优先级不会高于线程组设置的最大优先级。

另外，线程组中有一个 stop 方法用来终止组内所有的线程，但这个方法和 Thread 中的 stop 方法一样会带来很多问题，所以它们两个现在都已经被废弃了，官方也是不建议使用了，建议使用线程中断功能进行优雅终止线程。

多线程 start 和 run 方法区别？

首先要知道实现多线程最基本的两种方式：

1、继承 java.lang.Thread 类；

2、实现 java.lang.Runnable接口；

其中 Thread 类也是实现了 Runnable 接口，而 Runnable 接口定义了唯一的一个 run() 方法，所以基于 Thread 和 Runnable 创建多线程都需要实现 run() 方法，是多线程真正运行的主方法。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

而 start() 方法则是 Thread 类的方法，用来异步启动一个线程，然后主线程立刻返回。该启动的线程不会马上运行，会放到等待队列中等待 CPU 调度，只有线程真正被 CPU 调度时才会调用 run() 方法执行。

所以 start() 方法只是标识线程为就绪状态的一个附加方法，以下 start() 方法的源码，其中 start0() 是一个本地 native 方法。

public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

请注意，start() 方法被标识为 synchronized 的，即为了防止被多次启动的一个同步操作。

那么你会问了，为什么要有两个方法，直接用一个 run() 方法不就行了吗！？ 还真不行，如果直接调用 run() 方法，那就等于调用了一个普通的同步方法，达不到多线程运行的异步执行，来看下面的例子。

/**
 * 微信公众号：Java技术栈
 */
public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Java技术栈");
    });

    long start = System.currentTimeMillis();
    thread.start();
    System.out.println(System.currentTimeMillis() - start);

    start = System.currentTimeMillis();
    thread.run();
    System.out.println(System.currentTimeMillis() - start);
}

程序输出：

0
Java技术栈
3000
Java技术栈

从程序输出结果可以看出，启动 start 方法前后只用了 0 毫秒，而启动 run 方法则阻塞了 3000 毫秒等程序执行完再继续执行，这就是同步与异步的一个最重要的区别。