[进程与线程]--进程和线程的区别和联系-CSDN博客

        线程,进程包括线程;
        一个进程里面可以有一个线程,或者多个线程;
        每个线程都是一个独立的执行流,多个线程之间,也是并发执行的;
        多个线程可能是在多个 CPU 核心上,同时运行;
        也可能是在一个CPU核心上面,通过快速调度,并行运行;

其实操作系统,真正调度的,是在调度线程,而不进程,前面所述的进程调度: 是指进程里面只有一个线程;

进程是操作系统资源分配的基本单位;

线程是操作系统调度运行的基本单位;

线程轻量的原因

一个进程中的多个线程之间,共用同一份系统资源;

内存空间,
文件描述符表

只有在进程启动,创建第一个线程的时候,需要花成本去申请系统资源.

一旦进程(第一个线程)创建完毕,此时,后续再创建的线程,就不必再申请资源了,创建/销毁的效率就提高了不少了;比如创建10个线程干一件事,只需要申请一次资源,而创建10个进程,就需要申请10次资源,就会造成资源的浪费;

一、创建线程

1.1在Java中实现创建线程的五种写法

1.使用Thread ,重写 run方法来创建线程;

代码:

class myThread extends Thread {
    @Override
    public void run() {
        while(true) {
            System.out.println("hello t");
        }
    }
    //此刻这里继承 Thread 类
}
public class Demo1 {
    public static void main(String[] args) {
        Thread t = new myThread();
        t.start();   //这里的start就是创建一个新的线程去执行run里面的方法;
        while(true) {
            System.out.println(" t");
        }
    }
}

这里的 start 就是创建一个新的线程去执行;结果也就是两个循环交替打印;
而看代码中run方法是特殊的方法,会被自动调用到,如果是普通方法,就必须通过手动去调用;
如果start 两次的话就会失败;

执行结果:

线程是能够交替运行,但是打印出来的结果肯定是有先有后的,因为是两个线程往同一个控制台上打印,同一个控制台必须得顺序输出~;

再给打印的时候加个sleep 1秒打印一次后的结果:

public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new myThread();
        t.start();   
        while(true) {
            Thread.sleep(1000);   //直接通过类名来调用sleep单位是毫秒
            System.out.println(" t");
        }
    }
}

执行结果:

从图中可以看出来,对于多个线程在CPU上的调度的顺序是随机的 ,虽然系统的调度是有优先级的,但是这个优先级只能说是''建议'',不是决定;也就是你说你的, 我做我的;

2.实现 runnable ,重写run方法;

1.创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数.

runnbale 字面意思是可运行的
使用 runnalbe描述一个具体的任务;
通过run方法来描述;

class myRunnable implements Runnable {
    @Override
    public void run() {
        while(true) {
            System.out.println("hello  t ");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new myRunnable();
        Thread t = new Thread(runnable);
        t.start();
        while(true) {
            Thread.sleep(1000);
            System.out.println("sssss");
        }
    }
}

这种写法是使用 Runnable interface 来描述线程入口; 和第一种起到的效果是一样的;

3.使用集成Thread ,使用匿名内部类

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        //相当于Thread 的子类
        Thread t = new Thread() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("thdsa");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start();
        while(true) {
            System.out.println("aaaaa");
            Thread.sleep(1000);
        }
    }
}

4.实现Runnable ,使用匿名内部类(定义在类当中的类;)

{}大括号放到哪里,就是针对哪个类创建匿名内部类;

代码:

public class Temo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        while(true) {
            Thread.sleep(1000);
            System.out.println("11111");
        }
    }
}