线程详解(代码片段)

对于一个CPU而言，它在某个时间点只能执行一个程序，也就是说，只能运行一个进程，
CPU不断地在这些进程之间轮换执行，虽然CPU在多个进程间轮换执行，但是我们感觉到好像有多个进程在同时进行

线程是进程的执行单元，对于绝大多数的应用程序来说，通常仅要求有一个主线程，
但也可以在该进程内创建多条顺序执行流，这些顺序执行流就是线程（子线程），
每个线程也是相互独立的

线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量，
但不拥有系统资源，它与父进程的其他线程共享该进程所有拥有的全部资源

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

public class Test2 extends Thread

    // 重写run方法，run方法的方法体就是子线程的执行体
    @Override
    public void run() 
        for (int i = 0; i < 100; i++) 
            // 继承Thread类后，从父类继承的getName方法可以获取当前线程的名称
            System.out.println("线程名称："+this.getName()+" "+i);
        
    

    public static void main(String[] args) 
        for (int i = 0; i < 100; i++) 
            // 调用Thread的currentThread()方法获取当前线程对象
            // 这里就不能用this来获取name了
            System.out.println("线程名称；"+Thread.currentThread().getName()+"="+i);

            //创建两个子线程，并运行
            if (i == 20)
                new Test2().start();
                new Test2().start();
            
        

    


线程是以抢占式的方式运行的，虽然只创建了两个线程实例，实际上有三个线程在运行
（两个子线程，一个主线程main）

通过setName(String name)的方式来为线程设置名称，也可以通过getName的方式来得到线程的名称。
在默认情况下，主线程的名称为main，用户启动的多线程的名称依次为Thread-0,Thread-1,Thread-3..Thread-n

public class Test3 implements Runnable
    @Override
    public void run() 
        for(int i = 0;i < 100;i++) 
            // 实现了Runnable接口的类其本质并不是线程类，因此没有getName方法，
            // 因此需要通过Thread类来获取当前线程，仅仅是一个任务体，仍需交给Thread去执行
            System.out.println("线程名称："+Thread.currentThread().getName()+" "+i);
        
    

    public static void main(String[] args) 
        /*new一个实现了Runnable接口的实例，这个实例不是线程对象
        * 不能test3.start()来运行子线程，执行run方法体
        * 实际的线程对象要通过new Thread()来获取，只不过对于实现了Runnable接口的实现类的实例
        *   作为参数传入到new Thread(test3).start()来执行子线程
        *   意义是让线程对象来执行test3实例的run方法体
        * */
        Test3 test3 = new Test3();
        new Thread(test3).start();
        new Thread(test3).start();
    

public class Test4 




    public static void main(String[] args) 

        /*
        * 用lamda表达式的写法，里面写的就是run方法体
        * 将runnable传入到 new Thread(runnable,"子线程1")里面，就表示了创建了子线程
        *   并执行run方法体，第二个参数是为子线程起名字
        * */
        Runnable runnable = ()->
            for (int i = 0; i < 100; i++) 
                System.out.println("线程名字："+Thread.currentThread().getName()+"="+i);
            
        ;

        Test4 test4 = new Test4();
        new Thread(runnable,"子线程1").start();
        new Thread(runnable,"子线程2").start();
    

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

/**
 * 实现Callable接口时指定的泛型为返回值的类型
 */
public class Test5 implements Callable<Integer> 

    /*
    * 对于实现了Callable接口的类，重写的call方法就是子线程要执行的方法体
    *   这个call方法与run方法的区别就是，call有返回值，可以声明抛出异常
    *
    * 实现的Callable接口可以看做是Runnable接口的增强版，所以可以提供一个Callable对象作为target传给线程对象
    *   但是问题就是，Callable接口不是Runnable接口的子接口，不能直接作为target
    *   call方法有返回值
    *
    * */
    @Override
    public Integer call() throws Exception 
        for (int i = 0; i < 100; i++) 
            /*与实现了Runnable接口的run方法相似，也是不能使用this来获取name*/
            System.out.println("当前线程名称："+Thread.currentThread().getName()+" "+i);
            Thread.sleep(200);
        
        return 100;
    

    public static void main(String[] args) throws ExecutionException, InterruptedException 
        /*创建Callable对象,因为当前类实现了Callable接口  多态*/
        Callable<Integer> callable = new Test5();
        // 创建FutureTask对象，并将call对象封装在FutureTask内部，FutureTask的泛型为Callable
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        /*创建线程对象*/
        new Thread(futureTask).start();
        // 获取线程结束后的返回值
        System.out.println("线程执行结束后的返回值："+futureTask.get());

    

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

public class Test6 

    public static void main(String[] args) throws Exception 
        /*
        * Callable接口也是一个函数式接口，所以可以用lamda表达式写法
        *  里面写的就是call的方法体
        * */
        Callable<Integer> callable = ()->
            for (int i = 0; i < 100; i++) 
                System.out.println("线程名称:"+Thread.currentThread().getName()+"="+i);
            
            return 100;
        ;

        // 创建FutureTask对象，并将call对象封装在FutureTask内部，FutureTask的泛型为Callable
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        /*创建线程对象  并将FutureTask封装好的Callable对象传入线程对象中*/
        new Thread(futureTask).start();

        // 获取线程结束后的返回值
        System.out.println("线程执行结束后的返回值："+futureTask.get());