多线程基础学习（一）——线程概念和创建多线程的方式

最新推荐文章于 2021-05-24 01:16:55 发布

chuanwen0451

最新推荐文章于 2021-05-24 01:16:55 发布

阅读量107

点赞数

文章标签：操作系统 java 测试

原文链接：https://my.oschina.net/alexjava/blog/3008152

版权

一、线程和进程

进程：一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

线程：通常在一个进程中可以包含若干个线程，至少会有一个。线程可以利用进程所拥有的资源，是独立运行和独立调度的基本单位。

区别：每个进程拥有自己的一整套变量，而线程则共享数据。在有些操作系统中，线程比进程更“轻量级”，创建、撤销一个线程比启动新进程的开销要小得多。

进程的三个特征：

》独立性：进程是系统中独立存在的实体，拥有自己的独立资源和私有的地址空间。

》动态性：程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。

》并发性：多个进程可以在单个处理器上并发执行，进程之间不会互相影响。

并行：同一时刻，有多条指令在多个处理器上同时执行

并发：同一时刻，只能有一条指令执行。

多线程的优点：

》进程之间不能共享内存，但线程之间共享内存很容易。

》系统创建进程时需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程实现多任务并发比多进程的效率高。

》Java语言内置了多线程的功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程编程。

二、实现多线程的方法

继承Thread类

1.定义Thread类的子类，重写其run()方法，该run方法即为线程执行体。

2.创建Thread子类的实例，即创建线程对象。

3.调用线程对象的start()方法来启动线程。

/**
 * Thread子类，run()中为线程执行体
 **/
public class MyThread extends Thread {
    private int i;
    @Override
    public void run() {
        super.run();
        while (i<10){
            i++;
            System.out.println(Thread.currentThread() + "："+i);
        }
    }
}

/**
 * Thread实现多线程-单元测试
 **/
public class MyThreadTest {
    @Test
    public void testMyThread(){
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread1.start();
        myThread2.start();
    }
}

打印结果：

由上面打印结果可见，Thread-0和Thread-1两个线程，打印的i值不连续。是因为i是MyThread的实例变量，而不是局部变量。程序每次创建线程对象时都需要创建一个MyThread对象，所以Thread-0和Thread-1不能共享该实例变量。

结论：

1.使用继承Thread类的方法创建线程类时，多个线程之间无法共享线程类的实例变量。

2.默认情况下，主线程名字为main，用户启动的多个线程的名字依次为Thread-0、Thread-1、…、Thread-n等。

Thread.currentThread()：Thread类的静态方法，返回当前正在执行的线程对象。

getName()：Thread类的实例变量，返回调用该方法的线程的名字。

setName()：设置线程名称。

实现Runnable接口创建线程类

1.定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法为线程执行体。

2.创建Runnable实现类的实例，以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

3.调用线程对象的start()方法来启动该线程。

/**
 * Runnable接口实现类，run()为线程执行体
 **/
public class MyRunnable implements Runnable {
    private int i;
    public void run() {
        while (i<10){
            i++;
            System.out.println(Thread.currentThread().getName()+"：i="+i);
        }
    }
}

/**
 * 实现Runnable接口来实现多线程-单元测试
 **/
public class MyRunnableTest {
    @Test
    public void testMyRunnable(){
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        t1.start();
        t2.start();
    }
}

由打印结果可看，Thread-0和Thread-1打印的i值，是连续的。是因为这种情况下，程序创建的Runnable对象只是线程的target，而多个线程可以共享一个target，所以多个线程可以共享一个线程类（实际上是线程的target类）的实例变量。

结论：

1.Runnable对象仅仅作为Thread对象的target，Runnable实现类的run()方法仅作为线程执行体。实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

2.通过继承Thread类来获得当前线程，直接使用this即可；通过实现Runnable接口来获得当前线程对象，则必须使用Thread.currentThread()方法。

3.采用Runnable接口的方式创建的多线程，可以共享线程类的实例变量。

使用Callable和Future创建线程

Callable接口提供call()方法作为线程执行体，但是call()方法比run()方法功能更强大。

》call()方法可以有返回值。

》call()方法可以声明抛出异常。

Java提供了Future接口来代表Callable接口里call()方法的返回值。并未Future接口提供一个FutureTask实现类，该实现类实现了Future接口，也实现了Runnable接口，这个FutureTask的实现类作为Thread类的target。

Callable+Future 创建有返回值的线程的步骤：

1.创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值，再创建Callable实现类的实力。

2.使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

3.使用FutureTask对象来作为Thread对象的target，创建并启动新线程。

4.调用FutureTask对象的get()方法，来获得子线程执行结束后的返回值。

代码示例：

/**
 * Callable接口实现类，实现call()方法作为线程执行体
 **/
public class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" i="+i);
        }
        return i;
    }
}

/**
 * Callable创建线程并获取返回值-单元测试
 **/
public class MyCallableTest {
    @Test
    public void testCallable(){
        Thread t = new Thread();
        FutureTask<Integer> task = new FutureTask<Integer>(new MyCallable());
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-"+i);
            if(i == 5){
                new Thread(task,"MyCallable Thread").start();
            }
        }
        try{
            //获取线程返回值
            System.out.println("字线程的返回值：" + task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

打印结果：（只截取部分）

call()方法会导致主线程被阻塞，直到call()方法结束并返回为止。

三、三种方式的对比

通过继承Thread类或实现Runnable、Callable接口都可以实现多线程，不过实现Runnable接口与实现Callable接口的方式基本相同，只是Callable接口定义的方法有返回值，也可以声明抛出异常。因此可以将实现Runnable接口和实现Callable接口归为一种方式。这种方式与继承Thread方式之间的主要差别如下。

采用实现Runnable、Callable接口的方式创建多线程的优缺点：

>线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

>在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好的体现面向对象的思想。

>劣势：编程稍稍复杂，如果需要访问当前线程，必须使用Thread.currentThread(）方法。

采用继承Thread类的方式创建多线程的优缺点：

>劣势：因为线程已经继承了Thread类，不能再继承其他父类。

>优势：编写简单，如果需要访问当前线程，直接使用this即可获得当前线程。

基于上面分析，一般推荐采用实现Runnable接口、Callable接口的方式来创建多线程。

Future API

boolean cancel(boolean mayInterruptIfRunning);试图取消该Future里关联的Callable任务。

V get()；返回Callable任务里call()方法的返回值。调用该方法导致主线程阻塞，必须等子线程结束后才会得到返回值。

V get(long timeout,TimeUnit unit); 返回Callable任务里call()方法的返回值。该方法最多让程序阻塞timeout和unit指定的时间，如果经过指定时间Callable任务仍然没有返回值，将会抛出Timeout异常。

boolean isCancelled(); 如果Callable任务正常完成前被取消，则返回true。

boolean isDone(); 如果Callable任务已完成，则返回true。

转载于:https://my.oschina.net/alexjava/blog/3008152

chuanwen0451

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程基础学习（一）——线程概念和创建多线程的方式

一、线程和进程进程：一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。线程：通常在一个进程中可以包含若干个线程，至少会有一个。线程可以利用进程所拥有的资源，是独立运...
复制链接

扫一扫