Java多线程之线程创建与启动

最新推荐文章于 2024-07-08 14:19:47 发布

十一月上

最新推荐文章于 2024-07-08 14:19:47 发布

阅读量223

点赞数

分类专栏：多线程 Java 文章标签：多线程 Java 进程创建启动

本文链接：https://blog.csdn.net/xdzhouxin/article/details/80239063

版权

Java 同时被 2 个专栏收录

46 篇文章 0 订阅

订阅专栏

多线程

5 篇文章 1 订阅

订阅专栏

一、线程与进程

操作系统中可以支持多个程序同时运行，每个程序就代表了一个进程，各个程序即进程间相互独立工作，而每个程序中可能包含多个顺序执行流，每个执行流就代表了一个线程，各个线程共享进程中的资源。

1.什么是进程

进程是系统进行资源调度与分配的最小单位，一般而言，进程具有三个特点：

独立性：每个进程都有自己独立的私有资源，不与其他进程共享，也就是说，其他进程不可以直接访问其他进程的地址空间。
动态性：进程具有自己的生命周期和状态转变。
并发性：并发是指在同一时刻只能有一条指令执行，但多个进程可以被快速轮换执行，由于处理速度非常快，感觉上多个进程在同时进行。

2.什么是线程

线程也被成为轻量级进程，当进程中需要并发执行多个任务时，就需要使用线程的概念，线程是进程的执行单元，它们可以共享进程中的资源。

3.进程与线程的区别

进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元。
同一个进程中可以包含多个线程，一个进程中至少包含一个主线程。
同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量。
同一个进程中的线程可以并发执行。
线程间的通信比进程间通信要方便的多，但是线程之间需要处理好同步与互斥的关系。

二、线程的创建与启动

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例，Java中创建多线程有三种方法：

继承Thread类重写run方法
实现Runnable接口重写run方法
使用Callable和Future创建线程

1.继承Thread类创建线程类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该线程。

代码如下所示：

public class ThreadTest extends Thread{
    int i = 0;
    @Override
    public void run(){
        for(;i<50;i++){
            System.out.println(getName() + " " +i);
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadTest thread1 = new ThreadTest();
        ThreadTest thread2 = new ThreadTest();
        for(int i=0; i<50;i++){
            System.out.println(Thread.currentThread().getName()+"  : "+i);  
            if(i==10)  
            {
                thread1.start();
                thread2.start();
            }
        }
    }

}

运行结果可能如下所示：

main  : 15
Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
Thread-1 5
main  : 16
Thread-1 6
main  : 17
Thread-0 0
Thread-1 7
Thread-0 1
main  : 18
Thread-0 2
Thread-1 8
Thread-0 3
main  : 19
main  : 20
Thread-0 4

由测试结果可知，main进程执行至i=10时，开始新建两个新线程，两个新线程从i=0开始分别执行，Thread-0和Thread-1中的i值是不连续的，证明两个线程中的i值不共享，因为两个新线程是ThreadTest创建的两个实例，Thread-0和Thread-1不能共享实例变量。

2.实现Runnable接口创建线程类

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
（3）调用线程对象的start()方法来启动该线程。

代码如下所示：


public class RunnableTest implements Runnable{
    int i = 0;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(;i<50;i++){
            System.out.println(Thread.currentThread().getName() + " " +i);
        }

    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        RunnableTest runnable = new RunnableTest();
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
            if(i==20)  
            {  
                new Thread(runnable,"线程1").start();  
                new Thread(runnable,"线程2").start();  
            }  
        }  
    }

}

运行结果可能如下所示：

main 53
main 54
main 55
main 56
线程1 0
线程2 0
main 57
线程1 1
main 58
线程2 2
main 59
线程1 3
main 60
线程2 4
main 61

由测试结果可知，两个子线程的i值是连续变化的，说明使用Runnable接口的方式创建的多个线程可以共享线程类的实例变量。

3.使用Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值，call()方法还可以抛出异常。
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

实现代码如下所示：


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值
 * @author zhx
 *
 */
class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 计算1-100的和
        int sum = 0;
        for (int i = 1; i <= 100; i++)
            sum += i;
        return sum;
    }
}

public class CallableTest {

    public static void main(String[] args) {
        CallableDemo cd = new CallableDemo();
        //创建Callable实现类的实例，使用FutureTask类来包装Callable对象
        //该FutureTask对象封装了该Callable对象的call()方法的返回值
        FutureTask<Integer> result = new FutureTask<>(cd);
        //使用FutureTask对象作为Thread对象的target创建并启动新线程。
        new Thread(result).start();
        int sum = 0;
        // 接收运算结果
        // 只有当该线程执行完毕后才会获取到运算结果，等同于闭锁的效果
        try {
            //调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
            sum = result.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("sum is " + sum);
    }
}