Java基础—多线程

一、基本概念程序、进程、线程

1、程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

2、进程（process）：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

3、线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。

①若一个进程同一时间并行执行多个线程，就是支持多线程的

②线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小

③一个进程中的多个线程共享相同的内存单元/内存地址空间-->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患

 > 进程可以细化为多个线程。

> 每个线程，拥有自己独立的：栈、程序计数器

> 多个线程，共享同一个进程中的结构：方法区、堆

补充：并行与并发的理解

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。

二、线程的创建和使用

1、多线程的创建：方式一：继承于Thread类

①创建一个继承于Thread类的子类

②重写Thread类的run() ---> 将此线程执行的操作声明在run()中

③创建Thread类的子类的对象

④通过此对象调用start()

eg：遍历100以内的所有的偶数

//1、创建一个继承于Thread类的子类
class MyThread extends Thread{
    //2、重写Thread类的run()
    @Override
    public void run(){
         for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


public class ThreadTest{
    public static void main(String[] args){
        //3、创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4、通过此对象调用start()：① 启动当前线程 ②调用当前线程的run()
        t1.start();
        
        //注意点一：我们不能通过直接调用run()的方式启动线程。
        //t1.run();
        //注意点二：再启动一个线程，遍历100以内的偶数。
        //不可以还让已经start()的线程去执行。会报IllegalThreadStateException

        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();

        //如下操作仍然是在main线程中执行的
         for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }

    }

}

注意点一：我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。

注意点二：我们再启动一个线程，必须重新创建一个Thread子类的对象。调用此对象的start()。

2、多线程的创建：方式二：实现Runnable接口

①创建一个实现了Runnable接口的类

②实现类去实现Runnable中的抽象方法：run()

③创建实现类的对象

④将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

⑤通过Thread类的对象调用start()

eg：遍历100以内的所有的偶数

//1、创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //2、实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run(){
          for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest{
    public static void main(String[] args){
        //3、创建实现类的对象
        MThread mThread = new MThread();
        //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);//多态的体现：(Runnable target)
        t1.setName("线程1");
        //5、通过Thread类的对象调用start()：①启动线程 ②调用当前线程的run() ---> 调用了Runnable类型的target的run()
        t1.start();
        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

3、比较创建线程的两种方式

开发中，优先选择：实现Runnable接口的方式。

原因：①实现的方式没有类的单继承性的局限性。

           ②实现的方式更适合来处理多个线程有共享数据的情况。

联系：public class Thread implements Runnable ---> Thread类也实现Runnable接口

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。

              目前两种方式，要想启动线程，都是调用的Thread类中的start()。

4、Thread中的常用方法

①start()：启动当前线程；调用当前线程的run()

②run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

③currentThread()：静态方法，返回当前代码的线程

④getName()：获取当前线程的名字

⑤setName()：设置当前线程的名字

⑥yield()：释放当前CPU的执行权

⑦join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态

⑧stop()：已过时。当执行此方法时，强制结束当前线程

⑨sleep(long millitime)：让当前线程"睡眠"指定的millitime毫秒。在指定的millitime毫秒时间