1.进程

1.运行中的程序，当我们启动一个程序时，就启动了一个进程，操作系统就会为该进程分配空间。比如当我们打开浏览器时，操作系统将为浏览器分配新的空间。
，
2.进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程，有它自身的产生，存在和消亡的过程。

2.线程

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

1.单线程

同一个时刻，只允许执行一个线程。

2.多线程

同一个时刻，可以执行多个线程。比如一个应用商店，可以同时下载多个应用。

3.并发

同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单来说，单核cpu实现的多任务就是并发。

4.并行

在同一个时刻，多个任务同时执行，多核cpu可以实现并行

3.线程的基本使用

1.继承Thread类

1.演示继承thread类创建线程

go 进程 线程 协程 并发

pdf 0星 超过10%的资源 52KB

下载

//1.当一个类继承了Thread类，该类就可以当作线程使用。
//一般会重写run，写入自己的业务逻辑

重写run函数，每隔一秒输出一次Demo龙，20次后程序结束

package com;

/**
 * @version 1.0
 * @auther Demo龙
 */
//演示继承thread类创建线程
public class Thread01 {
    public static void main(String[] args) {
        //创建cat对象，可以当作线程使用
        Cat cat = new Cat();
        //启动线程
        cat.start();

    }
}
//1.当一个类继承了Thread类，该类就可以当作线程使用。
//一般会重写run，写入自己的业务逻辑
class Cat extends Thread{
    int times=0;
    @Override
    public void run() {//重写run，写入自己的业务逻辑
        while (true) {
            times++;
            //该线程每隔一秒，在控制台输出Demo龙。
            System.out.println("Demo龙 "+times+"次");
            //休眠一秒,ctrl+alt+t快捷键抛出异常
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(times==20){
                break;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

演示结果

2.当main线程启动一个子线程Thread-0时，主线程不会阻塞。

package com;

/**
 * @version 1.0
 * @auther Demo龙
 */
//演示继承thread类创建线程
public class Thread01 {
    public static void main(String[] args){
        //创建cat对象，可以当作线程使用
        Cat cat = new Cat();
        //启动线程
        cat.start();
        //当main线程启动一个子线程Thread-0时，主线程不会阻塞。
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程i="+i);
            //抛出异常
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
//1.当一个类继承了Thread类，该类就可以当作线程使用。
//一般会重写run，写入自己的业务逻辑
class Cat extends Thread{
    int times=0;
    @Override
    public void run() {//重写run，写入自己的业务逻辑
        while (true) {
            times++;
            //该线程每隔一秒，在控制台输出Demo龙。
            System.out.println("Demo龙 "+times+"次");
            //休眠一秒,ctrl+alt+t快捷键抛出异常
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(times==20){
                break;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

2.实现Runnable接口创建线程

1.java是单继承的，在某些情况下一个类可能已经继承了一个父类，所以无法继承Thread类来创建线程。
2.但是可以通过实现Runnable接口创建线程。

重写run函数，每隔一秒输出一次Demo龙，20次后程序结束

package com;

/**
 * @version 1.0
 * @auther Demo龙
 * 通过实现Runnable接口创建线程
 */
public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start();这里不能用start
        //此处应该创建Thread对象，把实现了Runnable接口的Dog对象放人Thread
        Thread thread=new Thread(dog);//代理模式
        thread.start();
    }
}
class Dog implements Runnable{//通过实现Runnable接口创建线程
    int times=0;
    @Override
    public void run() {
        while (true){
            times++;
            System.out.println("Demo龙+"+times+"次 "+Thread.currentThread().getName());
            //休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(times==10)
                break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

创建两个线程，一个线程每隔一秒输出”Demo龙“，一个线程每隔一秒输出“gggggg”

package com;

/**
 * @version 1.0
 * @auther Demo龙
 *  创建两个线程，一个线程每隔一秒输出”Demo龙“，一个线程每隔一秒输出“gggggg”
 */
public class Thread03 {
    public static void main(String[] args) {
        F1 f1 = new F1();
        F2 f2 = new F2();
        Thread thread1=new Thread(f1);
        Thread thread2=new Thread(f2);
        thread1.start();//启动第一个线程
        thread2.start();//启动第二个线程
    }
}
class F1 implements Runnable{
    int times=0;
    @Override
    public void run() {
        while (true){
            times++;
            System.out.println("Demo龙 "+times+"次 "+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (times==10)
                break;
        }
    }
}
class F2 implements Runnable{
    int times=0;
    @Override
    public void run() {
        while (true){
            times++;
            System.out.println("ggggg "+times+"次 "+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (times==10)
                break;
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

演示结果