栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

20.线程

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

20.线程

并行与并发
并行

        在同一时刻,有多个指令在多个CPU上同时执行

并发

        在同一时刻,有多个指令在单个CPU上交替执行

线程与进程
操作系统

        操作系统是多进程容器

进程

        进程是多线程的容器

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

单线程程序

        一个进程如果只有一条执行路径,则称为单线程程序

多线程程序

        一个进程如果有多条执行路径,则称为多线程程序

多线程的创建方式
方式一:继承Thread类

        Java是通过java.lang.Thread类代表线程
        按照面向对象的思想,Thread类提供了实现多线程的方式,所有的线程对象都必须是Thread类或其子类的实例

        每个线程的作用是执行一段程序流,即一段顺序执行的代码

方式:

        1.定义一个子类MyThread继承(extends)Thread类

        2.重写run()方法

        3.创建MyTread类的对象

        4.对象.start();,启动线程

例:

        

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("子线程创建完毕");
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.run();
    }
}

优点:

        编码简单

缺点:

        扩展性差,Java只能继承一个父类

1.为什么不直接调用了run方法,而是调用start启动线程?
        直接调用run方法会当成普通方法执行,此时相当于还是单线程执行
        只有调用start方法才是启动一个新的线程执行

2.把主线程任务放在子线程之前了。
        这样主线程一直是先跑完的,相当于是一个单线程的效果

总结

        1.线程对象调用start方法,start方法通知JVM为当前线程对象开辟新的方法栈执行空间, 执行当前线程对象的run方法
        2.每个线程的run方法执行空间属于线程私有
        3.某一个线程运行中出现异常,不会影响其它线程的执行(不考虑同步: 锁的问题)

方式二: 实现Runnable接口

方式:

        1.定义一个类MyRunnable实现(implements)Runnable接口

        2.在MyRunnable类中重写run()方法

        3.创建MyRunnable类的对象

        4.创建Thread类的对象,把MyRunnable对象作为构造器的形参

        5.Thread类的对象.start();,启动线程

Thread的构造器

优点:

        线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强


缺点:

        编程多一层对象包装,如果线程有执行结果是不可以直接返回的

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("子线程创建完毕");
    }
}
public class Test {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

方式二:实现Runnable接口(匿名内部类)

方式:

        1.可以创建Runnable的匿名内部类对象

        2.交给Tread处理

        3.调用线程对象.start();,启动线程

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程创建完毕");
            }
        });
    }
}

1.Thread类实现多线程与实现Runnable实现多线程的区别?

        如果一个类继承Thread,则不适合资源共享,但是如果实现了Runable接口的话,则很容易的实现资源共享

2.实现Runnable接口比继承Thread类所具有的优势:

        适合多个相同的程序代码的线程去共享同一个资源

        可以避免java中的单继承的局限性

        增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立

方式三:利用Callable,FutureTask接口实现

方式:

        1.得到任务对象

                1.1定义实现Callable,重写call方法,封装要做的事情

                1.2用FutureTask把Callable对象封装成线程任务对象

        2.把线程任务对象交给Thread处理

        3.调用Thread的start();,启动线程,执行任务

        4.线程执行完毕后,通过FutureTask的get方法去获取任务执行的结果

优点:

        线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强

缺点:

        编码复杂一点

FutureTask的API

对比三种方式

Thread类获取和修改线程名字

Thread类的API

        也可以通过让自定义类调用Thread类的有参构造器,在创建对象时可以赋值

获取到当前的线程对象的方法

        某些情况下,非Thread类子类对象没办法调用getName方法获取名称,我们可以通过此方法获取当前正在执行的线程对象再获取名字

Thread类的线程休眠方法

线程安全

        多个线程同时操作同一个共享资源的时候可能会出现业务安全问题

        多个线程        同时操作        同一个共享资源        

线程安全问题出现的原因:

        存在多线程并发
        同时访问共享资源
        存在修改共享资源

线程同步
方式一:同步代码块

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

作用:

        把出现线程安全的问题的核心代码给上锁

原理:

        每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行

格式:

synchronized(任意对象){

        多条语句操作共享

}

优点:

        解决了多线程的数据安全问题

缺点:

        当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率

1.锁对象用任意唯一的对象好不好呢?
        不好,会影响其他无关线程的执行

2.锁对象的规范要求:

        建议使用共享资源作为锁对象
        对于实例方法建议使用this作为锁对象
        对于静态方法建议使用字节码(类名.class)对象作为锁对象


方式二:同步方法

作用:

        把出现线程安全问题的核心方法给上锁

原理:

        每次只能一个线程进入,执行完毕以后自动解锁,其他线程才可以进来执行

格式:

修饰符 synchronized 返回值类型 方法名称(形参列表){

        操作共享资源的代码

}

同步方法底层原理:

        同步方法其实底层也是有隐式锁对象的,只是锁的范围是整个方法代码
        如果方法是实例方法:同步方法默认用this作为的锁对象,但是代码要高度面向对象!
        如果方法是静态方法:同步方法默认用类名.class作为的锁对象

1.是同步代码块好还是同步方法好一点?
        同步代码块锁的范围更小,同步方法锁的范围更大


方式三:Lock锁

        java.util.concurrent.locks.ReentrantLock

        为了更清晰的表达如何加锁和解锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便,广泛的锁定操作

        Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象

ReentrantLock实现Lock接口

Lock的API

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

public class MyRunnable implements Runnable {
    private int a = 100;
    public Lock lockObj = new ReentrantLock();

    @Override
    public void run() {
        System.out.println("子类线程创建成功");
        while (true) {
            lockObj.lock();
            a+=100;
            try {
                Thread.sleep(1);
                String name = Thread.currentThread().getName();
                System.out.println(name+"::"+a);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lockObj.unlock();
            }
        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        thread1.setName("线程一");
        thread2.setName("线程二");
        thread1.start();
        thread2.start();
    }
}

死锁

死锁是指:

        两个或两个以上的线程在执行过程中,由于竞争同步锁而产生的一种阻塞的现象
        若无外力作用,它们都将无法推进下去

线程状态介绍

生产者与消费者

多个线程操作共享数据,线程任务是相同

多个线程操作共享数据,线程任务不相同

        生产者实现步骤:
            1.判断是否有包子    布尔标记
            2.有: 等待
            3.没有:
                (1)生产一个包子:num++
                (2)修改标记: true
                (3)唤醒消费者
        消费者实现步骤:
            1.判断是否有包子    布尔标记
            2.没有: 等待
            3.有:
                (1)消费一个包子
                (2)修改标记: false
                (3)唤醒生产者

线程等待和唤醒的方法定义在java.lang.Object类中

 

public class BaoZi03 {
    private int num;//给包子进行编号
    //添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
    private boolean flag;
    //被消费者线程调用,表示消费(打印输出)一个包子
    public void xiaoFei() {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName+"消费第~~~~~"+num+"~~~~~个包子");
    }
    //被生产者线程调用,表示生产一个包子
    public void shengChan() {
        num++;
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName+"生产第..."+num+"...个包子");
    }
    public boolean getFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
public class Producer03 implements Runnable{
    //定义共享资源包子BaoZi类的对象
    private BaoZi03 bz;
    //构造方法
    public Producer03(BaoZi03 bz) {
        this.bz = bz;
    }
    @Override
    public void run() {
        while (true) {
            //添加同步代码块
            synchronized (bz) {
                if(bz.getFlag() == true) {
                    //有包子,生产者线程等待
                    try{bz.wait();}catch (Exception e){}//bz是锁对象           
                }
                //没有包子
                //生产一个包子
                bz.shengChan();
                //修改标记
                bz.setFlag(true);
                //唤醒消费者
                bz.notify();//bz是锁对象
            }
        }
    }
}
public class Consumer03 implements Runnable{
    //定义共享资源包子BaoZi类的对象
    private BaoZi03 bz;
    //构造方法
    public Consumer03(BaoZi03 bz) {
        this.bz = bz;
    }
    @Override
    public void run() {
        while (true) {
            //添加同步代码块
            synchronized (bz) {
                if(bz.getFlag() == false) {
                    try{bz.wait();}catch (Exception e){}//bz是锁对象
                }
                //有包子
                //消费一个包子
                bz.xiaoFei();
                //修改标记
                bz.setFlag(false);
                bz.notify();//bz是锁对象
                
            }
        }
    }
}
public class Demo03PC {
    public static void main(String[] args) {
        //创建线程共享资源包子类的对象
        BaoZi03 bz = new BaoZi03();
        //5.创建生产者线程任务对象
        Producer03 pTask = new Producer03(bz);
        //5.创建消费者线程任务对象
        Consumer03 cTask = new Consumer03(bz);
        //6.创建生产者线程对象,构造方法传递生产者线程任务对象
        Thread pThread = new Thread(pTask, "生产者线程");
        //7.创建消费者线程对象,构造方法传递消费者线程任务对象
        Thread cThread = new Thread(cTask, "消费者线程");
        //8.生产者线程对象调用start方法,开启线程进行生产
        pThread.start();
        //9.消费者线程对象调用start方法,开启线程进行消费
        cThread.start();
    }
}

优化代码
public class BaoZi04 {
    private int num;//给包子进行编号
    //添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
    private boolean flag;
    //被消费者线程调用,表示消费(打印输出)一个包子
    public synchronized void xiaoFei() {
        if (flag == false) {
            //没有包子,等待
            try {wait();}catch (Exception e){e.printStackTrace();}
        }
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName+"消费第~~~~~~"+num+"~~~~~~个包子");
        //修改标记
        flag = false;
        //唤醒生产者线程
        notify();
    }

    //被生产者线程调用,表示生产一个包子
    public synchronized void shengChan() {
        if(flag == true) {
            //有包子,等待
            try {wait();}catch (Exception e){e.printStackTrace();}
        }
        //没有包子,生产一个包子
        num++;
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName+"生产第..."+num+"...个包子");
        //修改标记
        flag = true;
        //唤醒消费者线程
        notify();
    }
    public boolean getFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

public class Producer04 implements Runnable{
    //定义共享资源包子BaoZi类的对象
    private BaoZi04 bz;
    //构造方法
    public Producer04(BaoZi04 bz) {
        this.bz = bz;
    }
    @Override
    public void run() {
        while (true)
            bz.shengChan();//生产一个包子
    }
}

public class Consumer04 implements Runnable{
    //定义共享资源包子BaoZi类的对象
    private BaoZi04 bz;

    //构造方法
    public Consumer04(BaoZi04 bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        while (true)
            bz.xiaoFei();//消费一个包子

    }
}
//测试类

public class Demo04PC {
    public static void main(String[] args) {
        //创建多线程共享数据资源baoZi类的对象
        BaoZi04 bz = new BaoZi04();
        //4.创建生产者线程任务对象
        Producer04 pTask = new Producer04(bz);
        //6.创建消费者线程任务对象
        Consumer04 cTask = new Consumer04(bz);
        //6.创建生产者线程对象,传递生产者线程任务对象
        Thread pThread = new Thread(pTask, "生产者线程");
        //7.创建消费者线程对象,传递消费者线程任务对象
        Thread cThread = new Thread(cTask, "消费者线程");
        //8.生产者线程对象和消费者线程对象分别调用start方法开启线程
        pThread.start();
        cThread.start();
    }
}

线程池

         线程池就是一个可以复用线程的技术

不使用线程池的问题:
        如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能

ExecutorService

        JDK5.0起提供了代表线程池的接口

获得线程池:

        方式一:

使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

 

        方式二:

使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象


ThreadPoolExecutor

ThreadPoolExecutor构造器的参数说明

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) 

ThreadPoolExecutor创建线程池对象示例

ExecutorService pools = new ThreadPoolExecutor(3, 5
        , 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
            Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());


ExecutorService的常用方法

新任务拒绝策略

 

参数一:指定线程池的线程数量(核心线程): corePoolSize       不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolSize      最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime                不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit                     时间单位
参数五:指定任务队列: workQueue                                               不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory                  不能为null
参数七:指定线程忙,任务满的时候,新任务来了怎么办: handler         不能为null

1.临时线程什么时候创建啊?
        新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程

2.什么时候会开始拒绝任务?

        核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝

Executors

Executors得到线程池对象的常用方法

        线程池的工具类通过调用方法返回不同类型的线程池对象

 

注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的

Executors使用可能存在的陷阱

        大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里开发手册)

1.Executors工具类底层是基于什么方式实现的线程池对象?
        线程池ExecutorService的实现类:ThreadPoolExecutor

2.Executors是否适合做大型互联网场景的线程池方案?
        不合适
        建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/978017.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号