线程创建

一个进程包含一个主线程main，如果要新建线程就需要，使用线程中的start（）方法，此时内核中出现了一个pcb对象，这个pcb就会让cpu执行对应的代码，

继承Thread类

创建线程需要使用Thread 类，来创建一个Thread 的实例，另一方面还需要给这个线程指定，要执行哪些指令/代码，指定指令的方式有很多种方式，此处先用种简单的，直接继承 Thread 类，重写Thread类中的run方法.

public class Create {
    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("我是一个线程");
            while (true){
            }
        }
    }
    //创建线程需要使用Thread 类，来创建一个Thread 的实例，
    //另一方面还需要给这个线程指定，要执行哪些指令/代码.
    //指定指令的方式有很多种方式，此处先用种简单的，直接继承 Thread 类，
    //重写Thread类中的run方法.
    public static void main(String[] args) {
        //当Thread对象创建出来的时候内核中并没有随之产生一个线程
        MyThread myThread = new MyThread();
        //执行了start（）方法才会创建一个新线程，此时内核中出现了一个pcb
        //这个pcb就会让cpu执行对应的代码，例如上面的run方法
        myThread.start();
        while (true){
        }
    }
}

通过匿名内部类方式继承Thread类

public class Create1 {
    //匿名内部类
    //创建了一个没有名字的类，只知道这类继承自Thread{}中是这个类的具体代码
    //同时也会new出这个类的实例
    Thread t = new Thread() {
        @Override
        public void run() {
            System.out.println("我是一个线程");
            while (true){
            }
        }

    };
    public static void main(String[] args) {
        //当Thread对象创建出来的时候内核中并没有随之产生一个线程
        Create1 create1 = new Create1();
        create1.t.start();
        //执行了start（）方法才会创建一个新线程，此时内核中出现了一个pcb
        //这个pcb就会让cpu执行对应的代码，例如上面的run方法
        while (true){

        }
    }
}

显式创建一个类实现Runnable接口，然后把这个Runnable的实例关联到Thread实例上

public class Create2 {
    //显示创建一个类实现Runnable接口
    //然后把这个Runnable的实例关联到Thread实例上
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println("我是一个新线程");
        }
    }

    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }

}

使用匿名内部类去重写runnable里的run方法来创建线程

public class Create3 {
        public static void main(String[] args) {
            //通过匿名内部类实现Runnable接口
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("我是一个新线程");
                }
            };
            Thread t = new Thread(runnable);
            t.start();
        }

    }

使用lambda表达式

public class Create4 {
    public static void main(String[] args) {
        //使用lambda表达式来指定线程执行的内容
        Thread t = new Thread(()-> {
            System.out.println("我是一个新线程");
        });
        t.start();
    }
}

操作系统
都一样
在细节上有点区别.
通过Runnable / lambda的方式来创建线程和继承Thread类相比，代码耦合性要更小一些在写Runnable或者lambda的时候run中没有涉及到任何的Thread相关的内容.
这就意味着很容易把这个逻辑从多线程中剥离出来,去搭配其他的并发编程的方式来执行.当然也可以很容易改成不并发的方式执行.

使用Callable/Future/FutureTask创建线程

• FutureTask是继承于Future的 所以使用FutureTask和Callable可以创建一个带返回值得多线程结果

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

public class Demo5 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个线程，计算1-1000的和

        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int ret = 0;
                for (int i = 0; i <=1000 ; i++) {
                    ret+=i;
                }
                return ret;
            }
        };

        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();


        //get方法堵塞，直到前面的call方法算完，才会返回
        Integer result = futureTask.get();
        System.out.println(result);


    }
}

500500

start和run方法

start（）
是要创建一个新的线程,由新的线程来执行输出.
run（）
只是一个普通的方法调用.没有创建新的线程.输出语句是在原线程中执行的.

查看线程

选择本地连接，选刚刚创建的类，之后连接，因为是本地的，不与其他的进行交互所以后面选不安全连接。

之后就可以进行查看

Thead常见构造方法

Thread 的几个常见属性

ID 是线程的唯一标识，不同线程不会重复
名称是各种调试工具用到
状态表示线程当前所处的一个情况
优先级高的线程理论上来说更容易被调度到
关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
是否存活，即简单的理解，为 run 方法是否运行结束了

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread("hh"){
            @Override
            public void run() {
                for (int i = 0; i < 10 ; i++) {
                    System.out.println(Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //run方法的执行过程就代表着系统内线程的生命周期
                //run方法执行中，内核的线程就存在
                //run方法执行完毕，内核中的线程随之销毁
                System.out.println("线程退出");
            }
        };
        //只要线程创建完毕，属性不变
        System.out.println(t.getName());
        System.out.println(t.getPriority());
        System.out.println(t.isDaemon());
        System.out.println(t.getId());
        //会随着线程的运行过程发生变化
        System.out.println();
        System.out.println(t.isAlive());
        System.out.println(t.isInterrupted());
        System.out.println(t.getState());

        t.start();
        while (t.isAlive()){
            System.out.println("hh 正在运行");
            System.out.println(t.getState());
            System.out.println(t.isInterrupted());
            Thread.sleep(300);

        }
    }
}