线程

线程

1. 线程的理解
   要想了解线程，就需先了解进程，进程是静态的，比如如何让我们编完的代码运行起来，因为静态代码是放在代码区的。如果想要它跑起来，我们一般用到的是：

public static void main(String[] args){

    Student stu=new Student("jack",12);
    stu.setName("mary");

}

这就开辟了一个主线程，当程序执行到：stu.setName("mary");这里时，就开辟一个分支，每个分支都是一个子线程，但这没有创建新的线程，只是到student这个对象中，去执行这个方法，然后再返回到主线程中。

但是，我们想要创建新的线程，那该怎么办呢？

1. 创建新线程
   我们一般有两种实现方式，一种是继承Thread类，重写run房后，启动该线程即可，比如：

public class MyThread  extends Thread{

    //这是线程的执行体，表示就绪状态
    @Override
    public void run() {

    }
}

但我们不建议直接继承Thread，因为java是单继承，支持多实现接口，如果我们继承了Thread，那么就没办法继承其他类，因而，我们推荐使用实现Runnable接口，重写run方法，new一个Thread对象，将实现类放在该对象中，并启动start，将线程启动，比如：

public class MyRunable implements Runnable {

    // 这是线程的执行体
    @Override
    public void run() 
        for (int i = 10; i >= 0; i--) {
            try {
                Thread.sleep(i*200) ;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("当前名" + Thread.currentThread().getName() + "的线程休息了"+(i*200)+ "毫秒");
        }
    }
}

我们怎么使用该实现类？首先，我们肯定要有个主线程，也就是我们常用的main函数，在main函数中启动子线程，比如：

public static void main(String[] args) {
    multyThreadTest();
}

/**
 * 这是多线程的测试
*/
private static void multyThreadTest() {

    int i = 0;

    MyRunable myRunable = new MyRunable();
    Thread thread = new Thread(myRunable);

    //调用thread.start();开辟新的线程
    //mmyRunable和主线程（main）同时进行
    thread.start();

    for (; i <= 10; i++) {
        System.out.println("当前名" + Thread.currentThread().getName() + "的线程休息了" + (i * 200) + "毫秒");
    }
    try {
        Thread.sleep(i * 200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

    该进程中一共有两个线程，一个是主线程，和一个子线程，这两个线程是并行的：

假如，我们不启动start方法， 而是直接启动run方法，结果会是什么呢？

public static void main(String[] args) {
    singleThreadTest();
}

private static void singleThreadTest() {

    int i = 0;

    MyRunable myRunable = new MyRunable();
    //不开辟新的线程，直接进入子线程myRunable中，执行run方法里的逻辑
    myRunable.run();   

    /**
     * 如果注释掉下面的两句话，那么即便MyRunable实现Runable接口
     * 在执行体run()内定义了操作，但也没有办法执行，而它和普通方法
     * 差不多，也就是我们常说的，每一个分支都是一个线程，仅是单线程
     * 当该方法myRunable.run();执行完毕后，才能网下执行。
     * 当执行myRunable.run();时，线程也是主线程,即main线程
   */
    /*Thread thread = new Thread(myRunable);
    thread.start();*/

    for (; i <= 10; i++) {
        System.out.println("当前名" + Thread.currentThread().getName() + "的线程休息了" + (i * 200) + "毫秒");
    }
    try {
        Thread.sleep(i * 200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

如果注释掉下面的两句话，那么即便MyRunable实现Runable接口， 在执行体run()内定义了操作，但也没有办法执行，而它和普通方法 差不多，也就是我们常说的，每一个分支都是一个线程，仅是单线程。当该方法myRunable.run();执行完毕后，才能网下执行。 当执行myRunable.run();时，线程也是主线程,即main线程。

到这里，线程的理解还没结束。。。