16.1 并发编程基础——Java多线程

标签：Runnable Java Thread 线程 16.1 run 多线程方法 public

16.1 并发编程基础——Java多线程

16.1.1 引言

Java语言的一个重要特点是内在支持多线程的程序设计。多线程的程序设计具有广泛的应用。线程的概念来源于操作系统进程的概念。进程是一个程序关于某个数据集的一次运行。也就是说，进程是运行中的程序，是程序的一次运行活动。

线程则是进程中的一个单独的顺序控制流。线程和进程的相似之处在于，线程和运行的程序都是单独顺序控制流。线程运行需要的资源通常少于进程，因此一般将线程称为轻量级进程。线程被看作是轻量级进程是因为它运行在一个程序的上下文内，并利用分配给程序的资源和环境。

单线程的概念很简单，整个程序中只有一个执行线索，如图所示，作为单个顺序控制流，线程必须在运行的程序中得到自己运行的资源，如必须有自己的执行栈和程序设计器。线程内运行的代码只能在该上下文内。

多线程(multi-thread)是指在单个程序内可以运行多个不同的线程完成不同的任务，如下图所示

图17-1 单线程程序示意图图17-2 多线程程序示意图

很多应用程序是用多线程实现的，如服务器编程就要用到多线程。例如：Tomcat服务器内部采用的就是多线程，上百个客户端访问同一个WEB应用都是通过一个线程提供服务的。

注意：多线程与多任务不同。多任务是在操作系统下可同时运行多个程序，多线程是在一个程序中多个同时运行的控制流。

16.2.2 创建任务和线程

要实现多线程，就必须在主线程或其它已经存在的线程中创建新的线程对象。为了创建新线程，应该首先定义该线程要执行的任务。一般来说，为了定义线程的任务，需要定义一个实现java.lang.Runnable接口的任务类。

Runnable接口只定义了一个方法，格式如下:

public abstract void run()

这个方法要由实现Runnable接口的类实现。Runnable对象称为任务对象，现成要执行的任务就写在run()方法中。

Thread类是线程类，该类的实例就是一个线程。Thread类实现了Runnable接口，该类的常用构造方法如下:

public Thread(String name):创建一个指定名称的线程对象，name为线程名

public Thread(Runnable target):创建一个线程对象，并制定target为线程运行的任务对象，该对象的类型为Runnable

public Thread(Runnable target,String name):指定线程名和任务对象创建一个线程。

当一个线程对象调用start()方法启动后即执行任务对象的run()方法，Thread类实现Runnable接口，因此Thread对象本身也可以实任务对象，若没有指定任务对象，则以当前类对象为任务对象。若没有指定线程名，则由系统指定。

Thread类的常用方法如下:

public void run():任务对象执行的方法，通常在Thread的子类中覆盖该方法。
public void start():启动线程开始执行，由JVM调用任务对象的run()方法实现
public static Thread currentThread():返回当前正在执行线程对象的引用。
public Thread.State():返回当前线程的状态，是Thread.State枚举的一个值。
public void setName(String name):设置线程名
public String getName():返回线程名
public static void sleep(long mills):使当前正在执行的线程暂时停止执行指定的时间。指定的时间结束后，线程继续执行。该方法抛出InterruptedException异常，必须捕获或声明抛出。
public void setDaemon(boolean on)：设置线程为Daemon(后台)线程
public boolean isDaemon():返回线程是否为Daemon(后台)线程
public static void yield():使当前执行的线程暂停执行，允许其他线程执行
public void interrupt():中断当前线程
public boolean isAlive():返回指定线程是否处于活动状态

线程运行的代码就是实现了Runnable接口类的run()方法或是Thread子类的run()方法，因此构造线程任务有以下两种方法。

实现Runnable接口并实现它的run()方法
继承Thread类并覆盖它的run()方法

16.2.3 实现Runnable接口

可以定义一个类实现Runnable接口，然后将该类对象作为线程的任务对象。实现Runnable接口就是实现run()方法。下面程序是通过实现Runnable接口构造任务类

package com.haozihua;

/**
 * @package: com.haozihua
 * @className: RunnableDemo
 * @Description:
 * @author: haozihua
 * @date: 2024/10/28 14:47
 */
public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "= " + i);
            try {
                Thread.sleep((int)(Math.random()*100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"  结束");
    }

    public static void main(String[] args) {
        RunnableDemo task=new RunnableDemo();
        Thread thread1=new Thread(task,"线程A");
        Thread thread2=new Thread(task,"线程B");
        thread1.start();
        thread2.start();

    }
}

RunnableDemo类实现了Runnable接口的run()方法，该方法是线程的任务。为了演示线程并发执行效果，程序调用了Thread类的sleep()方法使当前线程睡眠一段时间，使用sleep()方法要捕获 InterruptedException异常
main()方法创建两个线程对象并启动执行，两个线程执行相同的任务。下面是输出的部分结果

从输出结果可以看出，两个线程交替执行。构造线程时指定了执行的任务对象，所以线程启动后执行任务对象的run()方法

注意:程序中不要直接调用Runnable对象的run()方法。直接调用该方法，与调用其他的普通方法的效果一样，只会在同一线程中执行run()方法，不会启动新线程。不调用start()方法，线程永远不会开始运行。

16.2.4 继承Thread类

通过继承Thread类，并覆盖run()方法定义任务代码，这是可以用该类的实例作为线程的任务对象。下面的程序定义了ThreadDemo类，它继承Thread类并覆盖了run()方法

package com.haozihua;

import java.util.Random;

/**
 * @package: com.haozihua
 * @className: ThreadDemo
 * @Description:
 * @author: haozihua
 * @date: 2024/10/28 14:58
 */
public class ThreadDemo extends Thread {
    public ThreadDemo(String name) {
        super(name);
    }
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"  ="+i);
            try {
                Thread.sleep((int)(Math.random()*100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(getName()+"运行结束");

    }
    public static void main(String[] args) {
        Thread thread1=new ThreadDemo("线程A");
        Thread thread2=new ThreadDemo("线程B");
        thread1.start();
        thread2.start();
    }
}

程序继承Thread类并实现了run()方法，是线程执行的任务。在main()方法中创建线程时没有指定任务对象，任务对象是当前线程对象，因此在线程启动后执行本类的run()方法

前面介绍了创建线程的两种方法。第一种方法实现Runnable接口的确定是编程复杂一些，但这种方法可以扩展其他的类，更符合面向对象的设计思想。第二种方法的继承Thread类的优点是比较简单，缺点是如果一个类已经继承了某个类，它就不能再继承Thread类(因为Java语言只支持单继承)。例如，编写Java Applet就不能用这种方法。但是可以定义内部类，这样还可以访问外层类的成员。

16.2.4 主线程

当Java应用程序的main()方法开始运行时，Java虚拟机就启动一个线程，该线程负责创建其他线程，因此称为主线程。请看下面的程序

package com.haozihua;

public class MainThreadDemo {
    public static void main(String[] args) {
        Thread t=Thread.currentThread();
        System.out.println(t);
        System.out.println(t.getName());
        t.setName("MyThread");
        System.out.println(t);
    }
}

程序在main()方法中声明了一个Thread对象t，调用Thread类的静态方法currentThread()获得当前线程对象，该线程就是主线程。然后重新设置该线程对象的名称，最后输出线程对象(线程名、线程优先级和线程组名)

标签：Runnable,Java,Thread,线程,16.1,run,多线程,方法,public
From： https://blog.csdn.net/haozihua/article/details/143280397

16.1 并发编程基础——Java多线程