创建线程的方式

首先,先来了解一下什么是线程?什么是进程?

1.进程:是操作系统中一个程序的执行周期。

2.线程:是进程的一个任务,即操作系统中任务调度的基本单位。

3.进程与线程的区别:

  • 每个进程拥有自己的一整套变量,是操作系统资源分配的最小单位。
  • 线程依托于进程存在,多个线程可以共享进程的资源。
  • 启动、撤销一个进程的开销要比一个线程大得多。
  • 没有进程就没有线程,进程一旦关闭,所有的线程都会被撤销。

4.创建线程的三种方式:
(1) 继承类:
继承Thread类,并覆写run(),代码如下:

/**
 * @Author: lin
 * @Date: 2019/8/29 9:40
 * @Description:线程的创建方式1
 */

class MyThread extends Thread{
    private String name;
    public MyThread(String name){
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name+" running...");
    }
}

public class Test {
    public static void main(String[] args) {
        Thread thread1 = new MyThread("myThread1");
        Thread thread2 = new MyThread("myThread2");
        Thread thread3 = new MyThread("myThread3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

  • 我们能不能直接调用run()来启动多线程呢?来看下图:
    在这里插入图片描述
    答案是不能,因为此时相当于只是进行了顺序打印,这跟多线程没有关系。正确做法是调用start()启动多线程,此时我们的线程就会随机交替执行。
    在这里插入图片描述
  • start()解析:
public synchronized void start() {
        //若线程状态不为0,表示已经启动过,此时抛出异常
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        //表示此时线程还未启动
        boolean started = false;
        try {
            //调用native方法start0()启动线程
            start0();
            //此时线程已经启动
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

由上可见,当我们调用start()来启动线程的时候,会先判断这个线程是否已经启动过,若已经启动过则报错;若没有启动则调用了本地的start0()来启动线程。

调用start0()实际上会调用JVM_StartThread(),函数内创建了真正与平台相关的本地线程,然后再回调run(),执行我们所定义的线程的具体任务。

(2) 实现接口:

  • 实现Runnable接口,并覆写run(),代码如下:
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" running...");
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread,"myThread1");
        Thread thread2 = new Thread(myThread,"myThread2");
        Thread thread3 = new Thread(myThread,"myThread3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

我们来看一下,Thread与Runnable的描述:

public class Thread implements Runnable {...}

可见,Thread类与我自定义的类MyThread都实现了Runnable接口,Thread类负责系统资源调度,分配线程等操作,而MyThread用来实现真实业务。即通过实现Runnable接口来创建线程实际上是一种代理模式。

  • 实现Callable接口,并覆写call(),代码如下:
class MyThread implements Callable<String> {
    private int ticket = 10;
    @Override
    public String call() throws Exception {
        while(this.ticket>0){
            System.out.println("现在还有 "+this.ticket--+" 张票");
        }
        return "票已经售空!";
    }
}

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new MyThread();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

结果如下:
在这里插入图片描述
我们来画一下这之间的接口与类的关系:
在这里插入图片描述
(3)使用线程池:
一般我们使用ThreadPoolExecutor来创建一个线程,让我们先来看一下它的构造方法:

public ThreadPoolExecutor(    //线程池的基本大小
                              int corePoolSize,
                              //线程池允许创建的最大线程数
                              int maximumPoolSize,
                              //线程活动的保持时间
                              long keepAliveTime,
                              //线程活动保持时间的单位
                              TimeUnit unit,
                              //任务队列,用于保存等待执行的任务的阻塞队列
                              BlockingQueue<Runnable> workQueue,
                              //线程工厂
                              ThreadFactory threadFactory,
                              //当线程池处于饱和状态时,提交新任务所采取的策略
                              RejectedExecutionHandler handler)

使用ThreadPoolExecutor创建一个线程,代码如下:

class Threads implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" running...");
    }
}

public class TestPool {
    public static void main(String[] args) {
        Threads threads = new Threads();
        ThreadPoolExecutor thread =
                new ThreadPoolExecutor(3,5,
                        2000,TimeUnit.MILLISECONDS,
                        new LinkedBlockingDeque<Runnable>());
        for(int i = 0;i<5;i++){
            thread.execute(threads);
        }
        thread.shutdown();
    }
}

结果如下:
在这里插入图片描述
5.对比Thread、Runnable、Callable实现线程有什么不同?

  • 继承Thread类,覆写run(),可以满足一般创建线程的需要。
  • 实现Runnable接口所创建的所线程,可以更好地体现共享的概念。
  • 若当我们需要有一个返回值时,可以使用Callable创建多线程,使用FutureTask的get()来取得这个返回值。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值