Java多线程

Created2021-12-19Updated2021-12-19

实现多线程

进程和线程

进程: 是正在运行的程序

·是系统进行资源分配和调用的独立单位

·每一进程都有它自己的内存空间和系统资源

线程:

是进程中的单个顺序控制流，是一条执行路径

单线程:一个进程如果只有一条执行路径，则成为单线程程序

多线程:一个进程如果有多条执行路径，则成为多线程程序

举例:

(单线程)记事本程序，(多线程)扫雷游戏

多线程的实现方式

定义一个类MyThread继承Thread类
在MyThread类中重写run()方法
创建MyThread类的对象
启动线程

两个小问题:

为什么要重写run()方法呢？

因为run()是用来封装被线程执行的代码

run()方法和start()方法的区别

run():封装线程执行的代码,直接调用,相当于普通方法的调用

start():启动线程；然后由jvm调用此线程的run()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class day2继承Thread类的方式实现多线程 {
    public static void main(String[] args) {
        day2MyThread my1 = new day2MyThread();
        day2MyThread my2 = new day2MyThread();

        //my1.run();
        //my2.run();

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

设置和获取线程名称

Thread类中设置和获取线程名称的方法
·void setName(String name): 将此线程的名称更改为等于参数name
·String getName():返回此线程的名称
·通过构造方法也可以设置线程名称

如何获取main()方法所在的线程名称？
·public static Thread currentThread():返回对当前正在执行的线程对象的引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class day3设置和获取线程名称 {
    public static void main(String[] args) {
//        day3MyThread my1 = new day3MyThread();
//        day3MyThread my2 = new day3MyThread();
//        //void setName(String name): 将此线程的名称更改为等于参数
//        my1.setName("高铁");
//        my1.setName("飞机");

        //Thread(String name)
        day3MyThread my1 = new day3MyThread("飞机");
        day3MyThread my2 = new day3MyThread("高铁");

        my1.start();
        my2.start();

        //static Thread currThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class day3MyThread extends Thread {
    public day3MyThread(){

    }
    public  day3MyThread(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}

线程调度

线程有两种调度模型:

·分时调度模型:所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片

·抢占式调度模型:优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一点
Java使用的是抢占式调度模型

假设计算机只有一个CPU，那么CPU在某一时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。
所以说多线程程序的执行是随机性，因为谁抢到CPU的使用权是不一定的

Thread类中设置和获取线程优先级的方法:

1
public final void setPriority(int newPriority):更改此线程的优先级
1
public final int getPriority():返回此线程的优先级

线程默认优先级是5；线程优先级的范围是：1-10
线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

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
public class day4线程调度 {
    public static void main(String[] args) {
        day4MyThread tp1 = new day4MyThread();
        day4MyThread tp2 = new day4MyThread();
        day4MyThread tp3 = new day4MyThread();

        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");

        //public final int getPriority():返回此线程的优先级
//        System.out.println(tp1.getPriority());//5
//        System.out.println(tp2.getPriority());//5
//        System.out.println(tp3.getPriority());//5

// public final void setPriority(int newPriority):更改此线程的优先级
//        tp1.setPriority(10000);//IllegalArgumentException
//        System.out.println(Thread.MAX_PRIORITY);
//        System.out.println(Thread.MIN_PRIORITY);
//        System.out.println(Thread.NORM_PRIORITY);

        //设置正确的优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);

        tp1.start();
        tp2.start();
        tp3.start();
    }
}

线程生命周期

在这里插入图片描述

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
public class day6线程生命周期 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//////");
        });
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state); //new
        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//Run
        while (state != Thread.State.TERMINATED) {//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}

多线程的实现方式2

方式2:实现Runnable接口

·定义一个类MyRunnable实现Runnable接口

·在MyRunnable中重写run()方法

·创建MyRunnable类对象

·创建Thread类的对象,把MyRunnable对象作为构造方法的参数

·启动线程

多线程的实现有两种:

·继承Thread类

·实现Runnable接口

相比继承Thread类，实现Runnable接口的好处:

·避免了Java单继承的局限性

·适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码，数据有效分离，较好的体现了面向对象的设计思想

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class day7多线程的实现方式 {
    public static void main(String[] args) {
        //·创建MyRunnable类对象
        day7MyRunnable my = new day7MyRunnable();
        //把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        Thread t1 = new Thread(my,"高铁");
        Thread t2 = new Thread(my,"飞机");
        //启动线程
        t1.start();
        t2.start();
    }
}

1
2
3
4
5
6
7
8
9
10
public class day7MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);//这里不能直接使用getName方式
        }
    }
}

线程同步

共享数据安全问题

为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)

·是否是多线程环境
·是否有共享数据
·是否有多条语句操作共享数据

如何解决多线程安全问题呢？

·基本思想:让程序没有安全问题的环境

怎么实现呢?

把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

同步代码块：

锁多条语句操作共享数据的代码，可以使用同步代码块实现
·格式:
synchronized(任意对象){
多条语句操作共享数据的代码
}
·synchronized(任意对象):就相当于给代码加锁了，任意对象就可以看成是一把锁

同步的好处和弊端

·好处：解决了多线程的数据安全问题
·弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class day3卖票案例数据安全问题的解决 {
    public static void main(String[] args) {
        //  A:创建SellTicket对象
        day3SellTickets st = new day3SellTickets();
        //  B:创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口一");
        Thread t2 = new Thread(st,"窗口二");
        Thread t3 = new Thread(st,"窗口三");
        //  C:启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class day3SellTickets implements Runnable{
    private int tickets = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            }
        }
    }
}

同步方法

同步方法: 就是把synchronized关键字加到方法上

·格式:

修饰符synchronized返回值类型 方法名(方法参数){ }

同步方法的锁对象是什么呢：

·是this这个对象

同步静态方法: 就是把synchronized关键字加到静态方法上

·格式:

修饰符 static synchronized 返回值类型 方法名(方法参数){ }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class day4同步方法 {
    public static void main(String[] args) {
        day4SellTickets st = new day4SellTickets();

        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();


    }
}
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
package 多线程.线程同步;

public class day4SellTickets implements Runnable{
//    private int tickets = 100;
    private static int tickets = 100;
    private Object obj = new Object();
    private int x = 0;
    @Override
    public void run() {
        while(true){
            if (x%2==0) {
                //synchronized (obj) {
//                synchronized (this) {
                synchronized (day4SellTickets.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
                    }
                }
            }else{
//                synchronized (obj) {
//                    if (tickets > 0) {
//                        try {
//                            Thread.sleep(100);
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                        tickets--;
//                    }
//                }
                sellTicket();
            }
            x++;
        }
    }

//    private void sellTicket() {
//        synchronized (obj) {
//            if (tickets > 0) {
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                tickets--;
//            }
//        }
//private synchronized void sellTicket() {
//
//        if (tickets > 0) {
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//            tickets--;
//        }
//    }
private static synchronized void sellTicket() {

    if (tickets > 0) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
        tickets--;
    }
    }
}

线程安全的类

StringBuffer

·线程安全,可变的字符序列
·从版本JDK5开始，被StringBuilder替代。通常应该使用StringBuilder类。因为它支持所有相同的操作，但它更快，因为它不执行同步

Vector

·从Java2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Vector被同步。
如果不需要线程安全的实现，建议使用ArrayList代替Vector

Hashtable

·该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或者值
·从Java2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。
与新的集合实现不同，Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替Hashtable

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.io.StringBufferInputStream;
import java.util.*;

public class day5线程安全的类 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        StringBuilder sb2 = new StringBuilder();

        Vector<String> v = new Vector<>();
        ArrayList<String> array = new ArrayList<>();

        Hashtable ht = new Hashtable();
        HashMap<String,String> hm = new HashMap();

        //static <T> List<T> synchronizedList(List<T> list) 返回由指定列表支持的同步（线程安全）列表。
        Collections.synchronizedList(new ArrayList<>());
    }
}

Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们没有直接看到在哪里加上了锁，在哪里释放了锁，
为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
Lock中提供了获得锁和释放锁的方法

1
·void lock():获得锁
1
·void unlock():释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReentrantLock的构造方法
·ReentrantLock():创建一个ReentrantLock的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
public class day6Lock锁 {
    public static void main(String[] args) {
        day6SellTickets st = new day6SellTickets();

        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
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
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class day6SellTickets implements Runnable{
    private int tickets = 100;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try{
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}

生产者消费者案例

生产者消费者案例中包含的类:

奶箱类(Box):定义一个成员变量，表示第X瓶奶，提供存储牛奶和获取牛奶的操作

生产者类(Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作

消费者类(Customer):实现Runnable接口，重写run()方法，调用获取牛奶的操作

测试类(BoxDemo):这里面有main方法，main方法中的代码步骤如下

①创建奶箱对象，这是共享数据区域

②创建生产者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用存储牛奶的操作

③创建消费者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用获取牛奶的操作

④创建2个线程对象，分别把生产者和消费者对象作为构造方法参数传递

⑤启动线程

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
//奶箱类(Box):定义一个成员变量，表示第X瓶奶，提供存储牛奶和获取牛奶的操作

public class Box {
    //定义一个成员变量，表示第X瓶奶
    private int milk;
    //定义一个成员对象，表示奶箱的状态
    private boolean state = false;
    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk){
        //如果有牛奶，等待消费
        if (state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，生产牛奶
        this.milk = milk;
        System.out.println("送奶工将第"+this.milk+"瓶奶放入奶箱");

        //生产完毕之后，修改奶箱状态
        state = true;
        //唤醒其他等待的线程
        notifyAll();
    }
    public synchronized void get(){
        //如果没有牛奶，等待生产
        if (!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到了第"+this.milk+"瓶奶");
        //消费完毕之后，修改奶箱状态
        state = false;
        //唤醒其他等待的线程
        notifyAll();
    }
}

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
//测试类(BoxDemo):这里面有main方法，main方法中的代码步骤如下4
//  ①创建奶箱对象，这是共享数据区域
//  ②创建生产者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用存储牛奶的操作
//  ③创建消费者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用获取牛奶的操作
//  ④创建2个线程对象，分别把生产者和消费者对象作为构造方法参数传递
//  ⑤启动线程


public class BoxDemo {
    public static void main(String[] args) {
        //①创建奶箱对象，这是共享数据区域
        Box b = new Box();
        //②创建生产者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
        //③创建消费者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用获取牛奶的操作
        Customer c = new Customer(b);
        //④创建2个线程对象，分别把生产者和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        //启动线程
        t1.start();
        t2.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Customer implements Runnable{
    private Box b;
    public Customer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while(true){
            b.get();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//生产者类(Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作

public class Producer implements Runnable {
    private Box b;
    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 30; i++) {
            b.put(i);
        }
    }
}