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

Dear 丶 2022-05-25 04:53 316阅读 0赞

# 一、线程与进程 #

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

## 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);
        }
    }

# 三、三种创建方式的对比 #

## 1.采用实现Runnable、Callable接口的方式创见多线程 ##

### 优势： ###

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

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

### 劣势： ###

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

## 2.使用继承Thread类的方式创建多线程 ##

### 优势： ###

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

### 劣势： ###

线程类已经继承了Thread类，所以不能再继承其他父类。