线程--相关概念、两种创建线程的方式

线程基础

一、线程相关概念

程序：是为完成特定任务、用某种语言编写的一组指令的集合。简单的说：就是我们写的代码

进程：

1. 进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的空间
2. 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程

线程：

1. 线程由进程创建的，是进程的一个实例
2. 一个进程可以拥有多个线程

其他相关概念：

1. 单线程：同一个时刻，只允许执行一个线程
2. 多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打
   开多个聊天窗口，一个迅雷进程，可以同时下载多个文件
3. 并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简
   单的说，单核cpu实现的多任务就是并发。
4. 并行：同一个时刻，多个任务同时执行。多核CPU可以实现并行

二、线程的基本使用

2.1 创建线程的两种方法

在Java中线程来使用有两种方法：

1. 继承Thread类，重写run方法

2. 实现Runnable接口，重写run方法

继承Thread类

案例：

1)请编写程序，开启一个线程，该线程每隔1秒。在控制台输出“喵喵，我是小猫咪”

2）对上题改进：当输出80次 喵喵，我是小猫咪，结束该线程

3）使用JConsole 监控线程执行情况，并画出程序示意图！

public class Thread01{
    public static void main(String[] args){
        //创建一个Cat对象，可以当作线程使用
        Cat cat = new Cat();
        
        //读源码
        /*
        	(1)
        	public synchronized void start(){
        	 start0();
        	}
        	(2)
        	//start0() 是本地方法，是JVM调用，底层是c/c++实现
        	//真正实现多线程的效果，是 start0()，而不是 run()
        	private native void start0();
        */
        
        
        cat.start();//启动线程->最终会执行cat的run方法
        
        //cat.run();为什么不像这样直接调用run？
        //run方法就是一个普通方法，如果直接调用run就不会启动子线程，即阻塞在这运行完run()再向下继续执行。只有主线程。
        
        
        //说明：当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
        //这是 主线程和子线程交替进行
        System.out.println("主线程继续执行" + Thread.currentThread().getName);
        for(int i = 0; i < 60; i++){
            System.out.println("主线程 i=" + i);
        }
    }
}

//说明
//1.当一个类继承了 Thread 类，该类就可以当作线程使用
//2.我们会重写 run方法，写上自己的业务逻辑
//3.run Thread 类，实现了 Runnable 接口的run方法
/*
    @Override
    public void run(){
        if(target != null){
            taeget.run();
        }
    }
*/
class Cat extends Thread{
    
    int times = 0;
    @Override
    public void run(){//重写run方法，写上自己的业务逻辑
        
        while(true){
            //每隔1秒。在控制台输出“喵喵，我是小猫咪”
            System.out.println("喵喵,我是小猫咪" + (++times));
            //让该线程休眠1秒 ctrl+alt+t，选try...catch...
            //sleep内的时间是按毫秒计算
            try{
                Thread.sleep(1000);
            } catch(InterruptedException e){
                e.printStackTrace();
            }
            if(times == 80){
                break;//当times 到80，退出while，这时线程也就退出了
            }
        }
        
    }
}


1. 当进程开始，main线程执行，start() 使得子线程 Thread-0 开始。
2. 在主线程和子线程交替进行（在60次内）
3. 60次后，主线程结束消失，子线程Thread-0继续执行剩下20次
4. Thread-0结束后，线程也就结束了，界面失去响应

实现Runnable接口

说明：

1. java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承
   Thread类方法来创建线程显然不可能了。
2. java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

案例：

请编写程序，该程序可以每隔1秒。在控制台输出“hi!"，当输出10次后，自动退出。请使用实现Runnable接口的方式实现。这里底层使用了设计模式【代理模式】

public class Thread02{
    public static void main(String[] args){
        Dog dog = new Dog();
        //dog.start(),这里不能调用start
        //创建了Thread对象，把dog对象（实现Runnable),放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable{//通过实现Runnable接口，开发线程
    
    int count = 0;
    @Override
    public void run(){
        while(true){
            System.out.println("小狗汪汪叫...hi" + (++count) + Thread.currentThread().getName());
            
            //休眠一秒
            try{
                Thread.sleep(1000);
            } catch(InterruptedException e){
                e.printStackTrace();
            }
            
            if(count == 10){
                break;
            }
        }
    }
}

代码模拟实现Runnable接口开发线程的机制

public class Thread02{
    public static void main(String[] args){
        
        Tiger tiger = new Tiger();//实现了Runnable
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();//运行结果："老虎嗷嗷叫"
    }
}


class Animal{}
class Tiger extends Animal implements Runnable{
    @Override
    public void run(){
        System.out.println("老虎嗷嗷叫");
    }
}

//线程代理类，模拟了一个极简的Thread类
class ThreadProxy implements Runnable{//可以把Proxy类当成Thread
    
    private Runnable target = null;//属性，类型是 Runnable
    
    @Override
    public void run(){
        if(target != null){
            target.run();//动态绑定（运行类型Tiger）
        }
    }
    
    public ThreadProxy(Runnable target){
        this.target = target;
    }
    
    public void start(){
        start0();//这个方法是真正实现多线程的方法
    }
    public void start0(){
        run();
    }
}