Java多线程 -- 01 线程的创建与启动

内容:进程创建(两种方法)

1.多线程的概述

#############################
第一种创建方法:通过创建线程对象,参数设置进程执行的方法以及方法的参数

(1)线程、进程、程序的区别与联系?(来源,《疯狂Java讲义》P716)

程序:只是一个静态的指令集合。
进程(Process):是一个正在系统中活动的指令集合(即进程是处于运行过程中的程序,并且具有一定的独立功能)进程是系统进行资源分配和调度的一个独立单位。进程具有:独立性动态性并发性
线程:是进程的组成部分,是线程的执行单元,是独立运行的。一个进程可以拥有多个线程,同理,一个线程必须有一个父进程

联系与区别:
进程中加入了时间的概念,进程具有自己的生命周期和各种不同的状态,这些概念在 程序中都是不具备的。线程拥有自己的堆栈、自己的程序计数器、自己的局部变量,但不拥有系统资源(因为这些资源是共享资源,是要与父进程中其他线程公用的)。

一个线程可以创建和撤销另一个线程,同一个进程中的多个线程之间可以并发执行。

总结:
1.一个程序运行后至少有一个进程,一个进程里至少要包含一个线程(可以包含多个线程)。
2.操作系统可以同时执行多个任务,每个任务就是进程;每个进程可以同时执行多个更小的任务,这每个更小的任务就是线程。

现在的操作系统都支持多进程的并发,但在具体的实现细节上可能因为硬件和操作系统的不同而采用不同的策略,常用的方式有:共用式的多任务操作策略(效率不高),抢占式多任务操作策略(效率高,如UNIX/LINUX、Windows2000等系统)

from multiprocessing import Process
import time

def f(name):
    time.sleep(0.2)
    print('hello',name,time.ctime())

if __name__ == '__main__':
    p_list = []
    for i in range(3):
        p = Process(target=f,args=('xxx',))
        p_list.append(p)
        p.start()
    for i in p_list:
        i.join()
    print('end')
(2)多线程的优势

当操作系统创建一个进程时,须为该进程分配独立的内存空间,并分配大量的相关资源;但创建一个线程则简单的多,因此使用多线程来实现并发比使用多进程来实现并发的性能要高的多

使用多线程的优点:
1.进程之间不能共享内存,但线程之间共享内存很容易
2.系统创建一个进程时,需要为该进程分配系统资源,但创建一个线程则付出的代价小的多,即使用多线程来实现多任务并发比多进程的效率高
3.Java语言内置了多线程功能支持,而不是单纯地作为底层操作系统的调度方式,从而简化了Java多线程的编程

#############################
第二种创建线程的方法:
1、创建类继承Process类
2、类里面覆盖run方法
3、创建对象,执行start方法开启线程

2.线程的创建与启动

Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例

创建线程的三种方式:

继承Thread类
实现Runnable接口
实现Callable接口

(1)方式1:继承Thread类
实现步骤:
1.定义Thread子类,并重写Thread类的run()方法,该方法体就是县城执行体
2.创建Thread类的实例,即创建线程对象(注意此时还没有启动)
3.调用线程对象的start()方法来启动该线程

这三个步骤缺一不可

public class ThreadTest extends Thread{

    public void run() {
        System.out.println(this.getName());
        System.out.println("run方法");
    }

    public static  void main(String[] args) {
        ThreadTest tt = new ThreadTest();//创建线程
        tt.start(); //启动线程
        System.out.println(Thread.currentThread().getName());
        System.out.println("main方法");       
    }
}

注意:
1.如果在启动线程处采用tt.run()的形式,则系统会将该线程对象tt当成普通对象,从而将run()方法当成普通方法,即不会启动新的线程
2.上面代码实际会产生两个线程,一个是显示创建,一个是主线程(main()的方法体就是主线程的执行体)
3.使用继承Thread类的方法来创建线程类时,多个线程之间是无法共享线程类的类实例变量

Thread中的重要方法:
Thread(); //创建Thread的对象
Thread(Runnable target); //根据传入的Runnable接口的实现类实例来创建Thread接口
Thread(Runnable target, String name); //在创建线程对象时为其指定名字
static Thread currentThread(); //返回当前正在执行的线程对象
String getName(); //返回调用该方法的线程的名字
void setName(String name); //为调用该方法的线程重新设置线程名字

(2)方式2:实现Runnable接口
步骤:
1.定义实现Runnable接口的类,并重写Runnable接口的run()方法,即线程执行体
2.创建Runnable实现类的实例(注意,这并不是线程对象)。并以此实例作为Thread的target来创建Thread对象。此时该Thread对象才是真正的线程对象
3.调用线程对象的start()方法来启动该线程

public class RunnableTest implements Runnable{
    public void run() {
        System.out.println(Thread.currentThread().getName());
        System.out.println("run方法");
    }

    public static  void main(String[] args) {
        RunnableTest rt = new RunnableTest();// 1
        Thread tt = new Thread(rt);// 2
        tt.start();// 3
        System.out.println(Thread.currentThread().getName());
        System.out.println("main方法");       
    }
}

注意:在这种方式下,创建的多个线程是可以共享线程类的实例变量。因为,这里创建的Runnable实现类的实例只是作为线程的target,而多线程是可以共享同一个target,这样多个线程就可以共享同一个线程类

(3)方式3:使用Callable和Future创建线程
通过实现Runnable接口来创建线程的本质是:通过Thread类来讲Runnable类的run()方法包装成了线程执行体。但是请注意,不可以直接将其他的任意方法包装成线程执行体。(C#中可以)

Callable接口提供了call()方法可以作为线程执行体,但是该方法有返回值,且可以声明抛出异常

由于Callable并不是Runnable接口的子接口,因此不能直接作为Thread的target使用,

public interface Callable<V> {
    V call() throws Exception;
} 

Java5提供了一个Future接口,可以用来封装call()方法的返回值,

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning); // 试图取消该Future里关联的Callable任务
    boolean isCancelled();//如果在Callale任务正常完成前被取消,则返回true
    boolean isDone();//如果Callable任务以完成则返回true
    V get() throws InterruptedException, ExecutionException;//返回call()方法的返回值,调用该方法将导致程序阻塞,必须等待子线程结束后才会得到返回值
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;//在规定的timeout和unit时间内阻塞,超时后会抛出TimeOutException
}

该接口有个实现类,FutureTask,实现了Runnable接口,因此可以将这个返回值作为Thread的target,从而就将Callable的call()方法与Thread关联起来了。

public class FutureTask<V> implements RunnableFuture<V> {

    public FutureTask(Callable<V> callable) {...}
}

创建步骤:
1.创建Callable:创建Callable接口的实现类,并实现call()方法,作为线程执行体。并创建该实现类的实例
2.封装Callable:使用FutureTask类来包装Callable对象的call()方法返回值,FutureTask(Callable<V> callable)
3.创建线程并启动:使用FutureTask对象作为Thread对象的target创建线程对象,并启动。
4.获取返回值:调用FutureTask对象的get()方法来获得子线程执行体结束后的返回值

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;


public class CallableTest{  
    public static  void main(String[] args) throws Exception{
        MyCallable mc = new MyCallable(); //1
        FutureTask<Integer> ft = new FutureTask<Integer>(mc); //2
        Thread t = new Thread(ft); //3
        for(int i = 0; i < 20; i++) {
            if(i == 4) {
                t.start(); //3
            }
            System.out.println(Thread.currentThread().getName());
            System.out.println("main方法");   
        }
        System.out.println(ft.get());//4
    }
}

class MyCallable implements Callable<Integer>{
    public Integer call() {
        System.out.println("call方法");
        Integer i = new Integer(12); 
        return i;
    }
}

本文由金沙官网线上发布于编程,转载请注明出处:Java多线程 -- 01 线程的创建与启动

您可能还会对下面的文章感兴趣: