当前位置 : 主页 > 编程语言 > 其它开发 >

多线程

来源:互联网 收集:自由互联 发布时间:2022-05-30
实现多线程进程 进程是正在运行的程序 是系统进行资源分配和调用的单位 每一个进程都有它自己的内存空间和系统资源 线程 线程是进程中的单个顺序控制流,是一条执行路径 单线程
实现多线程 进程

进程是正在运行的程序

  1. 是系统进行资源分配和调用的单位
  2. 每一个进程都有它自己的内存空间和系统资源
线程

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

  1. 单线程:一个线程如果只有一条执行路径,则成为单线程程序
  2. 多线程:一个线程如果有多条执行路径,则称之为多线程程序
多线程的实现方式 方式1:继承Thread类

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

public class Thread01 {
    public static void main(String[] args) {
        MyThread01 mt1 = new MyThread01();
        MyThread01 mt2 = new MyThread01();
//        mt1.run();
//        mt2.run();
        // Calls to 'run()' should probably be replaced with 'start()'
        mt1.start();
        mt2.start();
    }
}
class MyThread01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

思考:
为什么要重写run()方法?
因为run()是用来封装被线程执行的代码
run()和start()方法的区别?
run():封装线程启动的代码,直接调用,相当于普通方法的调用
start():启动线程,然后由JVM调用此线程的run()方法

方式2:实现Runnable接口
  • 定义一个类MyRunnable实现Runnable接口
  • 在MyRunnable类中重写run()方法
  • 创建MyRunnable对象
  • 创建Thread对象,把MyRunnable对象作为构造方法的参数
  • 启动线程
    示例
public class Thread04 {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        //public Thread(Runnable target)
//        Thread t1 = new Thread(myRunnable);
//        Thread t2 = new Thread(myRunnable);
        //public Thread(Runnable target, String name)
        Thread t1 = new Thread(new MyRunnable(),"高铁");// 匿名内部类使用
        Thread t2 = new Thread(new MyRunnable(),"飞机");

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

    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

相比继承Thread类,实现Runnable接口的好处:
避免了Java单继承的局限性
适合多个相同程序的代码去处理同一个资源的情况,把线程、程序的代码和数据 有效分离、较好的体现了面向对象的思想

设置和获取线程名称

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

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

public class Thread02 {
    public static void main(String[] args) {
//        MyThread02 mt1 = new MyThread02();
//        MyThread02 mt2 = new MyThread02();
//
//        // void setName(String name):
//        mt1.setName("高铁");
//        mt2.setName("飞机");
//      有参构造
        MyThread02 mt1 = new MyThread02("高铁");
        MyThread02 mt2 = new MyThread02("飞机");
        mt1.start();
        mt2.start();
        //public static Thread currentThread();
        System.out.println(Thread.currentThread().getName());
    }
}
class MyThread02 extends Thread{
    public MyThread02() {
    }

    public MyThread02(String name) {
        super(name);
    }

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

线程调度

线程有两种调度模式:

  1. 分时调度模型:所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片
  2. 抢占式调度模型:优先让优先级高的线程占使用CPU,如果线程的优先级相同,那么会随机选择一个,
    优先级高的线程获取的CPU时间片相对多一些

Java使用的是抢占式调度模型

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

Thread类中设置和获取线程优先级的方法:
    public final int getPriority():返回此线程的优先级
    public final void setPriority(int newPriority):更改此线程的优先级。

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

public class Thread03 {
    public static void main(String[] args) {
        MyThread03 mt1 = new MyThread03();
        MyThread03 mt2 = new MyThread03();
        MyThread03 mt3 = new MyThread03();
        mt1.setName("飞机");
        mt2.setName("高铁");
        mt3.setName("汽车");
        // public final int getPriority()
//        System.out.println(mt1.getPriority());// 5
//        System.out.println(mt2.getPriority());// 5
//        System.out.println(mt3.getPriority());// 5

        // public final void setPriority(int newPriority)
        mt1.setPriority(10);
        mt2.setPriority(5);
        mt3.setPriority(1);
        mt1.start();
        mt2.start();
        mt3.start();
    }
}
class MyThread03 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
线程控制 方法名 说明 static void sleep(long millis) 使当前正在执行的线程停留(暂停执行)指定的毫秒数 void join() 等待这个线程死亡,即运行结束 void setDaemon(Boolean on) 将此线程标记为守护线程,当运行的线程都是守护线程时,Java虚拟机将退出 示例
public class ThreadControl {
    public static void main(String[] args) {
//        new ThreadSleepDemo();
//        new ThreadJoinDemo();
        new ThreadDaemonDemo();
    }
}
class ThreadSleepDemo {
    public ThreadSleepDemo() {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");

        ts1.start();
        ts2.start();
        ts3.start();

    }
    class ThreadSleep extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(getName() + ":" + i);
                // static void sleep(long millis):使当前执行的线程暂停(1s)再继续执行
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class ThreadJoinDemo{
    public ThreadJoinDemo()  {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();
        //为了使第一个线程结束再继续接下来的线程,使用void join()方法:等待这个线程死亡
        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");
        tj1.start();
        // 某个线程使用join()方法,不影响它之前线程的执行,但是它之后的线程需要等待此此线程结束才能执行
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
    class ThreadJoin extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(getName() + ":" + i);
            }
        }
    }
}

class ThreadDaemonDemo {
    public ThreadDaemonDemo() {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();

        td1.setName("关羽");
        td2.setName("张飞");
        // 设置主线程为刘备,要求在主线程结束时其他线程也结束
        Thread.currentThread().setName("刘备");
        //void setDaemon(Boolean on):将将此线程标记为守护线程,当运行的线程都是守护线程时,Java虚拟机将退出
        // **但是,不会立即退出**
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }
    class ThreadDaemon extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(getName() + ":" + i);
            }
        }
    }
}

线程生命周期

下图是线程从开始到结束的运行过程周期,值得注意的是,在运行过程中或者没有执行资格执行权的情况下,会返回到就绪状态抢夺CPU的执行权进而继续执行线程
image

线程同步 卖票案例引出
案例:卖票
需求:某影院正在上映大片,共有100张票,而他有三个窗口卖票,请设计一个程序模拟该影院卖票

下列是代码块并包含分析

public class SellTicket implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
//        //相同的票出现了多次分析
//        while (true) {
//            // tickets = 100;
//            // t1,t2,t3
//            // 假设t1抢到了CPU的执行权
//            if (ticket > 0) {
//                //通过sleep()方法来模拟出票时间
//                try {
//                    Thread.sleep(100);
//                    // t1线程休息100毫秒
//                    // t2线程抢到了CPU的执行权,t2线程就开始执行,执行到这里的时候,t2线程休息100毫秒
//                    // t3线程抢到了CPU的执行权,t3线程就开始执行,执行到这里的时候,t2线程休息100毫秒
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                // 假设线程按照顺序醒过来
//                // t1线程抢到了CPU的执行权,在控制台输出:窗口1正在出售第100张票
//                System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + " 张票");
//                // t2线程抢到了CPU的执行权,在控制台输出:窗口2正在出售第100张票
//                // t3线程抢到了CPU的执行权,在控制台输出:窗口3正在出售第100张票
//                ticket--;
//                // 如果这三个线程是按照顺序来的,这里就执行了3次--操作,最终票就变成了97
//            }
//        }

        //出现了复数的票
        while (true) {
            // tickets = 1;
            // t1,t2,t3
            // 假设t1抢到了CPU的执行权
            if (ticket > 0) {
                //通过sleep()方法来模拟出票时间
                try {
                    Thread.sleep(100);
                    // t1线程休息100毫秒
                    // t2线程抢到了CPU的执行权,t2线程就开始执行,执行到这里的时候,t2线程休息100毫秒
                    // t3线程抢到了CPU的执行权,t3线程就开始执行,执行到这里的时候,t2线程休息100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 假设线程按照顺序醒过来
                // t1线程抢到了CPU的执行权,在控制台输出:窗口1正在出售第1张票
                // 假设t1继续拥有CPU的执行权,就会执行ticket--操作,ticket=0;
                // t2线程抢到了CPU的执行权,在控制台输出:窗口2正在出售第0张票
                // 假设t2继续拥有CPU的执行权,就会执行ticket--操作,ticket=-1;
                // t3线程抢到了CPU的执行权,在控制台输出:窗口1正在出售第-1张票
                // 假设t3继续拥有CPU的执行权,就会执行ticket--操作,ticket=-2;//并不会输出到这里
                System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + " 张票");
                ticket--;
                // 如果这三个线程是按照顺序来的,这里就执行了3次--操作,最终票就变成了97
            }
        }
    }
}
/*
    测试类
 */
class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();
        Thread t1 = new Thread(sellTicket, "窗口1");
        Thread t2 = new Thread(sellTicket, "窗口2");
        Thread t3 = new Thread(sellTicket, "窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
/*
	运行结果会出现重读卖票现象和出现负数现象(Jdk-10以上)
*/
由上述分析可得知买票问题出现原因:
    线程执行的随机性导致的。
卖票案例数据安全问题的解决

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

  • 是否是多线程环境
  • 是否有数据共享
  • 是否有多条语句操作共享数据
    如何解决多线程安全问题呢?
  • 基本思想:让程序没有安全问题的环境
    怎么实现呢?
  • 把多条语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可

同步代码块

锁多条语句操作共享数据,可以使用同步代码块实现

 格式:
	synchronized(任意对象){
		多条语句操作共享数据的代码
	}

synchronized(任意对象):相当于给代码加锁了,任意对象就可以看成一把锁
代码改进实现

// 同步代码块实现
public class SellTicket01 implements Runnable {
    private int ticket = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            // ticket = 100;
            // 假设t1抢到了CPU的执行权
            // 假设t2抢到了CPU的执行权,发现被锁上,直接等待结束再进去
            synchronized (obj) {
                // t1进来后,就会把这段代码给锁起来
                if (ticket > 0) {
                    try {
                        Thread.sleep(1000);
                        // t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + " 张票");
                    ticket--;
                }
            }
            //t1出来了,这段代码的锁就被释放了。
        }
    }
}
class SellTicket01Demo {
    public static void main(String[] args) {
        SellTicket01 sellTicket01 = new SellTicket01();
        Thread t1 = new Thread(sellTicket01,"窗口1");
        Thread t2 = new Thread(sellTicket01,"窗口2");
        Thread t3 = new Thread(sellTicket01,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
同步的好处与弊端
好处:解决了多线程的安全问题
弊端:当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,
无形中会降低程序的运行效率
同步方法
同步方法:就是把synchronized关键字加到方法上
 - 格式:
	修饰符 synchronized 返回值类型 方法名(方法参数) {}
	同步方法锁的对象是 this

同步静态方法:就是把synchronized关键字加到静态方法上
- 格式:
	修饰符 static synchronized 返回值类型 方法名(方法参数) {}
	同步静态锁的方法对象是 类名.class

代码方法实现

public class SellTicket02 implements Runnable {
    private static int ticket = 100;
    @Override
    public void run() {
        sellTicket();
    }

    // 同步普通方法
//    private synchronized void sellTicket(){
//        while (true) {
//            synchronized (this) {
//                if (ticket > 0) {
//                    try {
//                        Thread.sleep(1000);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + " 张票");
//                    ticket--;
//                }
//            }
//        }
//    }

    // 同步静态方法
    // 静态方法只能调用静态变量
    private static synchronized void sellTicket(){
        while (true) {
            synchronized (SellTicket02.class) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + " 张票");
                    ticket--;
                }
            }
        }
    }
}
/*
	测试类
*/
class SellTicket02Demo {
    public static void main(String[] args) {
        SellTicket02 sellTicket02 = new SellTicket02();
        Thread t1 = new Thread(sellTicket02, "窗口1");
        Thread t2 = new Thread(sellTicket02, "窗口2");
        Thread t3 = new Thread(sellTicket02, "窗口3");

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

线程安全的类介绍

StringBuffer

  • 线程安全,可变的字符序列。
  • 从版本JDK 5开始,这个类别已经被一个等级类补充了,这个类被设计为使用一个线程StringBuilder 。 StringBuilder应该使用StringBuilder类,因为它支持所有相同的操作,但它更快,因为它不执行同步。

Vector< E>

  • 从Java 2平台v1.2,这个类被改造为实现List接口,使其成为成员Java Collections Framework 。 与新集合实现不同, Vector是同步的。 如果不需要线程安全的实现,建议使用ArrayList代替Vector 。

Hashtable< E>

  • 该类实现了一个哈希表,它将键映射到值。 任何非null对象都可以用作键值或值。
  • 从Java 2平台v1.2,这个类被改造为实现Map接口,使其成为成员Java Collections Framework 。 与新的集合实现不同, Hashtable是同步的。 如果不需要线程安全的实现,建议使用HashMap代替Hashtable 。 如果需要线程安全的并发实现,那么建议使用ConcurrentHashMap代替Hashtable 。
    值得注意的是:
    如果在多线程中需要使用集合保证线程同步安全,常用Collections类中的 synchronized集合名称(集合名称 < T> name) ;方法,返回该集合,此时该线程是安全的。
    例如
    List < String> list = Collections.synchronizedList(new ArrayList<>());
    Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
Lock锁

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

  • Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化,可能具有完全不同的属性,并且可以支持多个相关联的对象Condition 。

    Lock提供了获得锁和添加锁的方法

  • void lock():获得锁

  • void unlock():释放锁

    Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来实例化
    ReentrantLock的构造方法

  • ReentrantLock():创建一个ReentrantLock的实例
    代码实现

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTicketLock implements Runnable {
    private int ticket = 100;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
		// //使用try是防止代码出现问题锁能正常关闭
            try {
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + " 张票");
                    ticket--;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}
class SellTicketLockDemo{
    public static void main(String[] args) {
        SellTicketLock sellTicketLock = new SellTicketLock();
        Thread t1 = new Thread(sellTicketLock, "窗口1");
        Thread t2 = new Thread(sellTicketLock, "窗口2");
        Thread t3 = new Thread(sellTicketLock, "窗口3");

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

生产者消费者 生产者消费者模式概述

image

image

生产者消费者案例

案例要求如下:
image
案例代码如下:

package com.Multithreading;
// 案例:生产者消费者模式
/*
    测试类
 */
public class BoxDemo {
    public static void main(String[] args) {
        Box box = new Box();
        Producer producer = new Producer(box);
        Customer customer = new Customer(box);
        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(customer);
        t1.start();
        t2.start();
    }
}
/*
   成员类
 */
class Box{
    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();
    }
}
/*
    生产者类
 */
class Producer implements Runnable{
    private Box box;

    public Producer(Box box) {
        this.box = box;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            box.put(i);
        }
    }
}
/*
    消费者类
 */
class Customer implements Runnable{
    private Box box;
    public Customer(Box box) {
        this.box = box;
    }

    @Override
    public void run() {
        while (true){
            box.get();
        }
    }
}
上一篇:CV算法一年工作总结与心得!
下一篇:没有了
网友评论