创建多线程的4种方式

创建多线程的4种方式

 

1.线程是什么？

        线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序程序都至少有一个线程，也即是程序本身。

2.线程状态

        Java语言定义了5种线程状态，在任意一个时间点，一个线程只能有且只有其中一个状态。，这5种状态如下：

（1）新建（New）：创建后尚未启动的线程处于这种状态

（2）运行（Runable）：Runable包括了操作系统线程状态的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。

（3）等待（Wating）：处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无限期等待和有限期等待，处于无限期等待的线程需要被其他线程显示地唤醒，没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态；有限期等待状态无须等待被其他线程显示地唤醒，在一定时间之后它们会由系统自动唤醒，Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。

（4）阻塞（Blocked）：线程被阻塞了，“阻塞状态”与”等待状态“的区别是：”阻塞状态“在等待着获取到一个排他锁，这个时间将在另外一个线程放弃这个锁的时候发生；而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。

（5）结束（Terminated）：已终止线程的线程状态，线程已经结束执行。

下图是5种状态转换图：

 

                

3.线程同步方法

        线程有4中同步方法，分别为wait()、sleep()、notify()和notifyAll()。

wait()：使线程处于一种等待状态，释放所持有的对象锁。

sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用它时要捕获InterruptedException异常，不释放对象锁。

notify()：唤醒一个正在等待状态的线程。注意调用此方法时，并不能确切知道唤醒的是哪一个等待状态的线程，是由JVM来决定唤醒哪个线程，不是由线程优先级决定的。

notifyAll()：唤醒所有等待状态的线程，注意并不是给所有唤醒线程一个对象锁，而是让它们竞争。

4.创建线程的方式

        在JDK1.5之前，创建线程就只有两种方式，即继承java.lang.Thread类和实现java.lang.Runnable接口；而在JDK1.5以后，增加了两个创建线程的方式，即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。

4.1继承Thread类

 

//继承Thread类来创建线程
public class ThreadTest {
 
    public static void main(String[] args) {
        //设置线程名字
        Thread.currentThread().setName("main thread");
        MyThread myThread = new MyThread();
        myThread.setName("子线程:");
        //开启线程
        myThread.start();
        for(int i = 0;i<5;i++){
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}
 
class MyThread extends Thread{
    //重写run()方法
    public void run(){
        for(int i = 0;i < 10; i++){
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

 

4.2实现Runnable接口

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

//实现Runnable接口 public class RunnableTest {        public static void main(String[] args) {         //设置线程名字         Thread.currentThread().setName("main thread:");         Thread thread = new Thread(new MyRunnable());         thread.setName("子线程:");         //开启线程         thread.start();         for(int i = 0; i <5;i++){             System.out.println(Thread.currentThread().getName() + i);         }     } }    class MyRunnable implements Runnable {        @Override     public void run() {         for (int i = 0; i < 10; i++) {             System.out.println(Thread.currentThread().getName() + i);         }     } }

4.3实现Callable接口

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//实现Callable接口
public class CallableTest {
 
    public static void main(String[] args) {
        //执行Callable 方式，需要FutureTask 实现实现，用于接收运算结果
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
        new Thread(futureTask).start();
        //接收线程运算后的结果
        try {
            Integer sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
 
class MyCallable implements Callable<Integer> {
 
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}
        

 相较于实现Runnable 接口的实现，方法可以有返回值，并且抛出异常。

4.4线程池

        线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提交了响应速度。

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程池实现
public class ThreadPoolExecutorTest {
 
    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPool threadPool = new ThreadPool();
        for(int i =0;i<5;i++){
            //为线程池分配任务
            executorService.submit(threadPool);
        }
        //关闭线程池
        executorService.shutdown();
    }
}
 
class ThreadPool implements Runnable {
 
    @Override
    public void run() {
        for(int i = 0 ;i<10;i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

}

 

Callable结合  Future 结合线程池 executorService

 ExecutorService executorService=Executors.newCachedThreadPool();

package com.toov5.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableThreadTest {

    public static void main(String[] args) throws InterruptedException,ExecutionException {
    ExecutorService executorService=Executors.newCachedThreadPool();
    //提交时候 线程池开始执行
    System.out.println("1主线程开始执行");
    Future<String> sFuture =  executorService.submit(new TaskCallable());
    System.out.println("hhhhh");
    String ResultStirng =  sFuture.get();  //下面线程执行的结果
    System.out.println("2结果："+ResultStirng);
    System.out.println("okokokok");
    } 
}
    class TaskCallable implements Callable<String>{  //可以返回线程结果
          @Override
        public String call() throws Exception {
            System.out.println("3正在执行任务，请等待五秒");
            Thread.sleep(5000);
            System.out.println("4执行完毕");
            return "这是返回结果";
             }
        
    }