线程类

计算机运行多个程序是多进程运行，比如一边打LOL一边听网易云。cpu其实一个时间只做一样事情，但是由于转换的时间非常短，让用户感觉cpu是在同时做多件事。我们的计算机运行一个程序时，程序中可以创建多个线程。程序是进程，程序中又可以创建线程，所以线程是比进程小的运行单位。程序为什么要创建线程呢？据我所知，程序中的代码都是顺序执行的，就是从上往下一条一条执行的。当一条卡住时，下一条就不能执行了，叫做线程阻塞。之前学到过，许多语句都会发生线程阻塞，比如scanner.hasNext()，serverSocket.accept()，还有最简单的线程阻塞就是while(true){}。如果线程发生阻塞，那下面的语句将没有机会获得cpu资源。从这个角度来说，如果把任务分为多个小任务，几个小任务排队共享cpu资源，一个任务代表一个线程，不同的线程不会发生阻塞，也就是线程之间不会相互影响。这里是不是要担心排队也会等待过久让后面的线程无法得到cpu资源呢？其实不用担心，我们可以设置线程的优先级，同一优先级的线程会均匀分配cpu资源的，具体怎么分的不太清楚。。

public class Test{
    public static void main(String args[]){
        while(true){
            System.out.println("hello");
        }
    }
}

程序会一直输出hello
一个主方法运行时，就被分配了一个主线程。由于只有一个线程，这个程序就是单线程的。
冷知识：如果这是你在while循环后面加上语句时，idea会报错说这些语句是无法到达的。
但是像下面这种，其实也是无法到达的。

import java.util.Scanner;

public class Test{
    public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            System.out.println(scanner.nextLine());
        }
        int r = 2;
        int a = 8;
        System.out.println(a*r);
    }
}

看看下面这个程序，两个while循环同时运行输出的，说明他们是在共享cpu资源。

public class Test{
    public static void main(String args[]){
        jisuan multi = new jisuan();
        Thread thread = new Thread(multi);
        thread.start();
        Thread thread1 = new Thread();
        while (true){
            System.out.println("happy");
            try {
                thread1.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class jisuan implements Runnable{
    @Override
    public void run() {
        Thread thread = new Thread();
        int r = 2;
        int a = 1;
        while ( a <= 10){
            System.out.println(a * r);
            a++;
            try {
                thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

如何创建一个线程类？
方法一，继承Thread，重写public void run()方法
方法二，实现Runnable，实现其run()方法。
在一个线程中可以加入其他线程，方法是先创建一个线程类对象，然后将这个线程对象作为参数新建一个Thread对象，使用Thread对象调用start()方法启动线程，该线程就已经开始排队请求cpu资源了，当被分配到cpu资源时自动执行run()方法。

方法将由系统自动调用而不再用户调用。

重新看了一遍菜鸟教程的多线程，虽然内容不多，但是还是由收获的。
学习线程先学习线程的生命周期

然后创建线程的方法，也就是Thread类的构造方法。Java的万物皆对象，在这里，线程就是Thread类的对象。但是Tread类中的run()方法就啥也没有，所以我们要继承Thread类去写自己的run()方法，其他方法也可以重写。如果使用的是实现Runnable接口的方法创建线程，需要使用到Thread的另外一个构造方法，就是Thread thread = new Thread(Rannable rannable)。Thread对象中由许多方法，最重要的方法就是start()方法，它可以让线程从新建状态变成就绪状态。run()方法由JVM调用。

public class Test{
    public static void main(String args[]){
        jisuan ji = new jisuan();
        Thread thread = new Thread(ji,"niaho");
        System.out.println(thread.getName());
        thread.start();
        while (true){
            System.out.println("happy");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class jisuan implements Runnable{
    @Override
    public void run() {
        int r = 2;
        int a = 1;
        while ( a <= 10){
            System.out.println(a * r);
            a++;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

继承Thread类

public class Test{
    public static void main(String args[]){
        jisuan jisuan = new jisuan();
        jisuan.start();
        while (true){
            System.out.println("happy");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class jisuan extends Thread{
    @Override
    public void run() {
        int r = 2;
        int a = 1;
        while ( a <= 10){
            System.out.println(a * r);
            a++;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}