多线程---1-CSDN博客

本文链接：https://blog.csdn.net/qq_52206533/article/details/117423689

文章目录

1.认识线程
2.创建线程

1.认识线程

进程是系统分配资源的最小单位，线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源的。
每个进程至少有一个线程存在，即主线程。
进程和线程的关系：
1. 一个进程是包含多个线程的
2. 线程和进程的（部分）区别：
  进程是系统分配资源源（CPU，内存）的最小单位，线程是系统调度CPU执行的最小单位。
  数据共享：同一个进程内的线程之间，可以共享资源，代价比较小。
  不同进程之间，要共享数据，需要进行进程通信。
3. 多线程的作用
  提高效率（尽可能重复利用系统资源：CPU）（需要注意的事项：创建线程，是比较耗费时间和资源的，所以要综合考虑同时执行指令（任务量）+创建的线程数+系统可用资源。
4. 使用场景：一个时间点，要同时做多件事（同时执行多行代码）
  一个QQ，打开以后，可以：
  收发消息，上传下载文件，产看图片/pdf格式/视频
  多线程来完成，否则，代码在阻塞等待时，无法做其他事情。

2.创建线程

2.1内部类

匿名内部类：在一个方法中，new一个类型/接口(){} ()指定构造方法，{}指定要重写的方法。
静态内部类：一个类的内部，类似静态变量的方式，定义一个类，使用的时候，和普通的类差不多。

public class JavaProcess {

    public static void main(String[] args) {
    //类的方式：
    A a = new A(){//匿名内部类，本质是A的子类，但是不等同A类型
        //可以重写方法，或不重写（继承）
        @Override
        public void pro() {
            System.out.println("pro");
        }
    } ;
    a.pro();
    //接口方式
    B b = new B() {//匿名内部类，B接口的实现类，不能等同于B
        @Override
        public void pro() {
            System.out.println("pro");
        }
    };
    b.pro();
    }
    //静态内部类
    static class A{
       public void pro(){
           System.out.println("a pro");
       };
    }
    //内部接口
    interface B{
       void pro();
    }
}

2.2多线程基础api

主要api，几乎都是对线程的状态的转变的操作

2.2.1创建线程

Thread的常见的构造方法

方法	说明
Thread()	创建线程对象
Thread（Runnable target)	使用Runnable对象创建线程对象
Thread（String name)	创建线程对象，并命名
Thread（Runnable target,String name)	使用Runnable对象创建线程对象，并命名

Thread： new一个Thread类的子类，Thread就是java中的线程

public class NewThread {

    public static void main(String[] args) {
        //匿名内部类加Thread创建线程
        Thread thread = new Thread(){//匿名内部类
            @Override
            public void run() {//线程要执行的任务
                System.out.println("ok");
            }
        };
        //继承Thread的方式创建线程
        A a = new A();
        Thread tt= new A();
    }
}
//继承的方式创建内部类
class A extends Thread{
    @Override
    public void run() {
        System.out.println("ok");
    }
}

Runnable： new一个Runnable接口的子类，传到Thread中执行，Runnable是Java中任务的概念，new一个Runnable，就是定义一个任务的描述，再传到Thread中执行

public class NewRunnable {

    public static void main(String[] args) {
        //使用Runnable创建一个任务，再创建线程
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("ok");
            }
        };
        Thread thread = new Thread(r);

        //以上的合并的写法
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("ok");
            }
        },"子线程");
    }
}

Callable

2.3.2 启动线程

start：线程启动的方法（启动以后，才表现并发，并行的特性）

void	start()导致此线程开始执行；Java虚拟机调用此线程的run方法

申请系统调度线程，让CPU执行（创建态——>就绪态），如果线程获取CPU时间片，就开始执行任务（Thread类中run方法就是任务的定义，或者是Runnable对象中的run方法）。
start Vs run 方法
start 会真正的启动一个线程，和调用start方法所在的线程，是并发并行执行的
run方法只是线程的任务定义，如果直接调用run方法，属于普通方法调用。
Java程序，运行main方法理解：表现为一个java程序(启动java虚拟机），运行了一个main线程。
main线程
1. 定义一个匿名内部类，创建一个队形
2. 创建一个线程，传入了一个Runnable任务
3. 启动tt线程：申请系统调度tt线程，让CPU执行

 Thread tt=new Thread(new Runnable() {
            @Override
            public void run() {//执行run方法（定义任务的方法）
                while(true){}
            }
        },"tt");//创建态
        tt.start();//创建态——>就绪态——>运行态
        System.out.println("tt start");