多线程应用

多线程：

1. 串行 和 并发

2. 进程 和 线程

a) 线程:

就系线程中的独立控制单元，线程控制着进程的进行，一个进程中，至少有一个线程；进程包含了线程

3. 为什么要使用多线程：

a) 为了更好的利用CPU资源，
b) 进程之间不能去共享数据，线程可以。
c) 系统创建进程时需要重新分配系统资源，而创建线程代价比较小
d) Java语言中，内置了多线程功能支持，简化了多线程编程。

4. 线程的声明周期：

对象的生命周期：从对象被实例化出来（new），到用完释放的过程，叫做对象的生命周期；

a) 新建 ：

从新建一个线程对象到程序start()这个线程之间的状态，都是新建状态

b) 就绪：

线程对象调用start()方法之后，就处于就绪状态,等待JVM里的线程调度器的调度。

c) 运行：

抢到了CPU资源可以运行，此时的线程就属于运行状态。

d) 等待/阻塞/睡眠：

在一个线程执行了sleep方法、suspend(挂起)等方法后，失去了CPU资源编程阻塞状态，在睡眠结束后课重新进入就绪状态。

e) 终止：

run()方法完成后或者发生其他终止条件的时候会切换到终止状态

5. 创建线程的方法

a) 继承Thread类：

i. 自定义类继承Thread类
ii. 重写Thread类中的run方法
iii. 调用线程的start方法

package com.zrgj.thread;

/**
 *  继承Thread类
 */
public class ThreadDemo1 {
    /*
        步骤：
            1. 自定义类继承Thread类
            2. 重写Thread类中的run方法
            3. 调用线程的start方法
     */

    public static void main(String[] args) {
        // 线程命名的方式
        // 1. 通过get/set进行命名
        /*Thread td = new Thread();
        td.setName("张三");
        System.out.println(td.getName());*/

        // 2. 通过构造方法
        /*Thread td = new Thread("李四");
        System.out.println(td.getName());*/

        // 3. 通过子类的方式命名
       /* ThreadDemo tt = new ThreadDemo("zhagsan");
        tt.setName("zhangsan");
        System.out.println(tt.getName());*/



        //创建两个线程
        ThreadDemo td = new ThreadDemo("zhangsan");
        ThreadDemo tt = new ThreadDemo("lisi");

        // 如果使用.run()方法，也会执行，但是会以单线程的方式执行
        // start()方法还在内部调用run方法
        td.start();
        tt.start();

        // 主线程运行
        for (int i = 0; i < 5; i++){
            System.out.println("主线程的运行: " + i);
        }



    }


    // 自定义子类去继承Thread类
    static class ThreadDemo extends Thread{


         ThreadDemo(String name) {
            super(name);
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程的运行：" + this.getName()  + "..." + i);
            }
        }
    }

}

package com.zrgj.thread;

/**
 * 2. 实现Runnable接口
 */
public class ThreadDemo2 {
    /*
        步骤：
            1. 定义类实现Runnable接口
            2. 重写Runnable接口中的run方法，将线程要运行的代码放到该run方法中
            3. 通过Thread类建立线程对象
            4. 将Runnable接口的子类对象作为实际参数传给Thread构造函数
            5. 调用Thread类中的start方法开启线程并调用Runnable接口中子类的run方法
     */

    public static void main(String[] args) {
        RunTest rt = new RunTest();

        // 3.4.建立线程对象,将Runnable接口的子类对象作为实际参数传给Thread构造函数
        Thread td = new Thread(rt);
        Thread tt = new Thread(rt);

        // 5.开启线程并调用run方法
        td.start();
        tt.start();


    }



    // 1.定义类实现Runnable接口
    static class RunTest implements Runnable{
        private int tick = 10;


        // 2.重写Runnable接口中的run方法，将线程要运行的代码放到该run方法中
        @Override
        public void run() {
            while (true){
                if (tick>0){
                    System.out.println(Thread.currentThread().getName() + "....." + tick);
                }
            }
        }
    }







}