[Java知识库]多线程，Thread，Runnable，Callable

多线程

1，什么是进程，什么是线程

• 1，进程：

  • ? 系统中运行的一个程序，程序一旦运行起来就是进程

• 2，线程：

  • ? 它被包含在进程之中，是进程中的实际运行单位，一条线程指的是进程中的一个单一顺序的控制流。
  • ? 一个进程中可以并发多个线程，每一条线程并行执行不同的任务。

并发和并行

• 并发：CPU一核，多线程操作同一个资源
• 并行：CPU多核，多个线程可以同时执行。

程序的运行原理

• 分时调度：所有线程轮流使用cpu的使用权
• 抢占式调度：优先让优先级最好的线程使用cpu，如果线程的优先级相同，那么cpu会随机挑选一个执行，Java使用的为抢占式调度。不提高程序的运行速度，但能够提高程序的运行效率。

2，创建线程的实现方式。

继承Thread类

• 将一个类声明为Thread的子类，这个子类重写了Thread的run（）方法，然后可以分配启动子类的实例。
  • start()方法是启动多线程，需要用继承Thread类的类对象来启动它，run（）方法里是多线程的执行体。

@SpringBootTest
public class ThreadDemo extends Thread{

    @Override
    public void run() {
        //this.getName()：获取当前对象的名字
        System.out.println("当前对象的名字是："+this.getName());
        for (int i=0;i<10;i++){
            System.out.println("Thread多线程");
            if(i%11==0){
                try{
                    //使用Thread类的sleep方法时候可能为出现异常，这里捕获异常
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("异常的出现");
                }
            }
        }
    }
    @Test
    void Test() throws Exception{
        //Thread.currentThread().getName()：获取这个线程的名字
        System.out.println("这个线程的名字是："+Thread.currentThread().getName());
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();//启动多线程
        for (int i = 0;i<10;i++){
            System.out.println("Thread主线程");
            if(i%9==0){
                Thread.sleep(9);
            }
        }
    }
}
//运行结果：
这个线程的名字是：main
Thread主线程
当前对象的名字是：Thread-3
Thread多线程
Thread主线程
Thread主线程
Thread主线程
Thread主线程
Thread主线程
Thread主线程
Thread主线程
Thread主线程
Thread主线程
Thread多线程
Thread多线程
Thread多线程
Thread多线程
Thread多线程
Thread多线程
Thread多线程
Thread多线程
Thread多线程

实现runnable接口

• 声明一个实现Runnable接口的类，这个类实现了run（）方法，可以分配类的实例，在创建Thread时作为参考，并启动
• 重写run()方法，启动时需要创建Thread类对象，同时创建时还要将实现Runnable接口的类对象放进去，再使用Thread类对象调用start（）方法启动多线程

@SpringBootTest
public class RunnableDemo implements Runnable{
    @Override
    public void run() { 
        System.out.println(Thread.currentThread()+"启动线程");
        for (int i=0; i<10;i++){
            System.out.println("Runnable多线程");
            if(i%11==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("出现异常");
                }
            }
        }
    }
    @Test
    void Test() throws Exception{
        //Thread.currentThread().getName()：获取这个线程的名字
        System.out.println("这个线程的名字是："+Thread.currentThread().getName());
        RunnableDemo runnableDemo = new RunnableDemo();
        //创建Thread类对象，将实现Runnable接口的类对象传入
        Thread thread = new Thread(runnableDemo);
        //使用Thread类对象调用start（）方法启动多线程
        thread.start();
        for (int i=0;i<10;i++){
            System.out.println("Runnable主线程");
            if(i%9==0){
                Thread.sleep(9);
            }
        }
    }
}

//执行结果
这个线程的名字是：main
Runnable主线程
Thread[Thread-2,5,main]启动线程
Runnable多线程
Runnable主线程
Runnable主线程
Runnable主线程
Runnable主线程
Runnable主线程
Runnable主线程
Runnable主线程
Runnable主线程
Runnable主线程
Runnable多线程
Runnable多线程
Runnable多线程
Runnable多线程
Runnable多线程
Runnable多线程
Runnable多线程
Runnable多线程
Runnable多线程

实现callable接口

• 声明一个实现Callable（）方法的类，它是有返回值的，这个类需要重写call方法，

@SpringBootTest
public class CallableDemo implements Callable<Boolean> {//Boolean返回值类型
    @Override
    public Boolean call() throws Exception { //重写call（）方法，call方法需要抛出异常
        System.out.println(Thread.currentThread()+"启动线程");
        for (int i=0;i<10;i++){
            System.out.println("Callable多线程");
            if (1%11==0){
                try {
                    Thread.sleep(10);
                }catch (Exception e){
                    e.printStackTrace();
                    System.out.println("出现异常");
                }
            }
        }
        return true;//返回结果
    }
    @Test
    void Test()throws Exception{
        //Thread.currentThread().getName()：获取这个线程的名字
        System.out.println("这个线程的名字是："+Thread.currentThread().getName());
        CallableDemo callableDemo = new CallableDemo();
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        //实现callable接口的类对象丢入线程池中去启动
        Future<Boolean> future  = executorService.submit(callableDemo);

        for(int i=0;i<10;i++){
            System.out.println("Callable主线程");
            if (i%9 == 0){
                Thread.sleep(9);
            }
        }
        //打印返回值
        System.out.println(future.get());
        //关闭服务
        executorService.shutdownNow();
    }
}

//执行结果

这个线程的名字是：main
Callable主线程
Thread[pool-1-thread-1,5,main]启动线程
Callable多线程
Callable多线程
Callable多线程
Callable多线程
Callable多线程
Callable多线程
Callable多线程
Callable多线程
Callable多线程
Callable多线程
Callable主线程
Callable主线程
Callable主线程
Callable主线程
Callable主线程
Callable主线程
Callable主线程
Callable主线程
Callable主线程
true