多线程（一）（创建多线程和线程常用方法、优先级等）

最新推荐文章于 2022-04-26 20:36:48 发布

笨蛋悠米

最新推荐文章于 2022-04-26 20:36:48 发布

阅读量260

点赞数

分类专栏： javase基础

本文链接：https://blog.csdn.net/weixin_46744534/article/details/107885186

版权

javase基础专栏收录该内容

21 篇文章 0 订阅

订阅专栏

初识多线程

进程可以细化为多个线程。
每个线程，拥有自己独立的：栈、程序计数器
多个线程，共享同一个进程中的结构：方法区、堆

一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发：

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事情。
并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。

多线程的创建，在jdk5之前有两种方法：（5之后的在后面）

方式一：继承于Thread类

 1.创建一个继承于Thread类的子类
 2.重写Thread类的run()  --->将此线程执行的操作声明在run()中
 3.创建Thread类的子类对象
 4.通过此对象调用start()

还可以直接使用匿名子类调用

方式二：实现Runnable接口

 1.创建一个实现了Runnable接口的类
 2.实现类区实现Runnable中的抽象方法：run()
 3.创建实现类的对象
 4.将此对象作为参数传递到Thread类的构造器中，创建Thread
 类的对象
 5.通过Thread类的对象调用start()

比较创建线程的两种方式：
开发中：优先选择：实现Runnable接口的方式
原因：

实现的方法没有类的单继承性的局限性
实现的方法更适合来处理多个线程有共享数据的情况。

联系：public class Thread implements Runnable （Thread类都继承了Runnable接口）
相同点：两种方式都需要重写run方法，将线程要执行的逻辑声明在run方法中

测试Thread中的常用方法：

start()：①启动当前线程；②调用当前线程的run()
run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread()：静态方法，返回执行当前代码的线程
getName()：获取当前线程的名字
setName()：设置当前线程的名字。（还可以重写构造器，直接起名）
yield()：释放当前cpu的执行权（可能立马又抢到）
join()：在线程a中调用线程b的join()，线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
stop()：已过时。当执行此方法时，强制结束当前线程
sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒（1000毫秒=1s）。在指定的millitime毫秒内，当前线程是阻塞状态
isAlive()：判断当前线程是否存活

线程的优先级：
线程优先级在1-10之间

默认的值的表示（也可以直接用数字代替）
MAX_PRIORITY：10
MIN_PRIORITY：1
NORM_PRIORITY：5 -->默认优先级
如何获取和设置当前线程的优先级：
getPriority()：获取线程的优先级
setPriority(int p)：设置线程的优先级

说明： 高优先级的线程要抢占低优先级cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有高优先级的线程执行完以后，低优先级的线程才执行。

通过继承Thread类完成多线程的例子和试验Thread的方法：
例子：遍历100以内的所有偶数

记得调用的是start方法，而不是run方法。如果调run方法是主线程里面的了。

public class test1 {
    public static void main(String[] args) {
    //3.创建Thread类的子类对象
        //方法二：写构造器
        thread1 tr1=new thread1("线程1");
        thread2 tr2=new thread2("线程2");
        //方法一，使用setName()来命名
//        tr1.setName("线程1");
//        tr2.setName("线程2");
	//4.通过此对象调用start()
        tr1.start();
        tr2.start();
        //创建thread类的匿名子类的方法
        new Thread(){
            public void run(){
                for (int i = 0; i < 20; i++) {
                    System.out.println(i);
                }
            }
        }.start();

		thread01 t1=new thread01();
        thread02 t2=new thread02();
        System.out.println("t1优先级:"+t1.getPriority());
        System.out.println("t2优先级:"+t2.getPriority());
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.setPriority(thread1.MIN_PRIORITY);
        System.out.println("t1优先级:"+t1.getPriority());
        System.out.println("t2优先级:"+t2.getPriority());
        t1.start();
        t2.start();
        System.out.println(t1.isAlive());
    }
}
//1.创建一个继承于Thread类的子类
class thread1 extends Thread{
    @Override
    //2.重写Thread类的run()
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName() +" "+i);
            }
        }
    }
    //构造器内存在给线程命名的方法
    public thread1(String name){
        super(name);
    }
}
class thread2 extends Thread{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==1){
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
        }
    }
    public thread2(String name){
        super(name);
    }
}
class thread01 extends Thread{
    public void run() {
        try {
            sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i=0;i<100;i++){
            if (i%2==1){
                System.out.println(Thread.currentThread().getName() +" "+i);
            }
            //释放当前cpu的执行权
//            if (i==20){
//                yield();
//                stop();
//            }
        }
    }
}
class thread02 extends Thread{
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName() +" "+i);
            }
        }
    }
}

通过实现Runnable接口完成多线程的例子：

public class Runnabetest {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread myThread=new MyThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1=new Thread(myThread);
        //5.通过Thread类的对象调用start()①启动线程 ②调用当前线程的run()  --->调用了Runnable类型的target中的run()
        t1.start();
        //在启动一个线程，遍历100以内的偶数
        Thread t2=new Thread(myThread);
        t2.start();
    }
}
//1.创建一个实现了Runnable接口的类
class MyThread implements Runnable{
    //2.实现类区实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName() +" "+i);
            }
        }
    }
}

小Demo：
三个窗口卖票，总票数100张

在继承Thread类完成多线程中，要定义：private static int ticket=100; 因为static池中的是全局通用的
而实现Runnable接口完成多线程中，要定义private int ticket=100; 因为只需要创建一个类的对象，给多个Thread类的对象就行

但是！都存在多发了第一张的情况！是因为存在线程的安全问题，待解决
问题解决在这里

多线程的创建，在jdk5之后有两种方法：

前两种是继承Thread类和实现Runnable接口

方式三：实现Callable接口

 1.创建一个实现Callable的实现类
 2.实现call方法，将此线程需要执行的操作声明在call()中
 3.创建Callable接口实现类的对象
 4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并start()
 6.（选做）获取Callable中call方法的返回值
 //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值

如何理解实现 Callable接口的方式创建多线程比实现 Runnable接口创建多线程方式强大？
1.call()可以有返回值的
2.call()可以抛出异常，被外面的操作捕获，获取异常的信息
3.Callable是支持泛型的

通过实现Callable接口完成多线程的例子：

public class Callabletset {
    public static void main(String[] args) throws FileNotFoundException {
        //3.创建Callable接口实现类的对象
        NumThread nm=new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask<Integer> futureTask=new FutureTask<>(nm);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并start()
        Thread t=new Thread(futureTask);
        FutureTask<Integer> futureTask1=new FutureTask<>(nm);
        Thread t1=new Thread(futureTask1);
        t.setName("第一：");
        t1.setName("第二：");
        t.start();
        t1.start();
        try {
            //6.（选做）获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Integer sum=futureTask.get();
            System.out.println("sum为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//1.创建一个实现Callable的实现类
class NumThread implements Callable<Integer>{
    @Override
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
                sum += i;
            }
        }
        return sum;
    }
}

加上同步后的方法：

//1.创建一个实现Callable的实现类
class NumThread implements Callable<Integer>{
    private int sum=0;
    @Override
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    public Integer call() throws Exception {
        synchronized (this) {
            for (int i = 0; i < 100; i++) {
                notify();
                if (i%2==0){
                    System.out.println(Thread.currentThread().getName()+":"+i);
                    sum += i;
                }
                wait();
            }
        }
        return sum;
    }
}

方式四：使用线程池

Java通过Executors提供四种线程池，分别为：
1）newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2）newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3）newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

工作流程：

	1.提供指定线程数量的线程池
		设置线程池的属性
	2.执行指定的线程操作。需要提供实现Runnable接口或者Callable接口实现类的对象
		.execute()：适合用于Runnable
		.submit()：适合用于Callable
	3.关闭连接池
		.shutdown()

好处：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理

ThreadPoolExecutor 构造函数重要参数分析
ThreadPoolExecutor 3 个最重要的参数：
corePoolSize : 核⼼线程数线程数定义了最⼩可以同时运⾏的线程数量。
maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运⾏的线程数
量变为最⼤线程数。
workQueue : 当新任务来的时候会先判断当前运⾏的线程数量是否达到核⼼线程数，如果达到
的话，新任务就会被存放在队列中。

ThreadPoolExecutor 其他常⻅参数:

keepAliveTime :当线程池中的线程数量⼤于 corePoolSize 的时候，如果这时没有新的任务提交，核⼼线程外的线程不会⽴即销毁，⽽是会等待，直到等待的时间超过了keepAliveTime 才会被回收销毁；
unit : keepAliveTime 参数的时间单位。
threadFactory :executor 创建新线程的时候会⽤到。
handler :饱和策略。关于饱和策略下⾯单独介绍⼀下。

ThreadPoolExecutor 饱和策略
ThreadPoolExecutor 饱和策略定义:
如果当前同时运⾏的线程数量达到最⼤线程数量并且队列也已经被放满了任
时， ThreadPoolTaskExecutor 定义⼀些策略:
ThreadPoolExecutor.AbortPolicy ：抛出 RejectedExecutionException 来拒绝新任
务的处理。
ThreadPoolExecutor.CallerRunsPolicy ：调⽤执⾏⾃⼰的线程运⾏任务。您不会任务请
求。但是这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加
队列容量。如果您的应⽤程序可以承受此延迟并且你不能任务丢弃任何⼀个任务请求的话，你可
以选择这个策略。
ThreadPoolExecutor.DiscardPolicy ：不处理新任务，直接丢弃掉。
ThreadPoolExecutor.DiscardOldestPolicy ：此策略将丢弃最早的未处理的任务请求。
举个例⼦： Spring 通过 ThreadPoolTaskExecutor 或者我们直接通过 ThreadPoolExecutor
的构造函数创建线程池的时候，当我们不指定 RejectedExecutionHandler 饱和策略的话来配置
线程池的时候默认使⽤的是 ThreadPoolExecutor.AbortPolicy 。在默认情况
下， ThreadPoolExecutor 将抛出 RejectedExecutionException 来拒绝新来的任务，这代
表你将丢失对这个任务的处理。对于可伸缩的应⽤程序，建议使⽤
ThreadPoolExecutor.CallerRunsPolicy 。当最⼤池被填满时，此策略为我们提供可伸缩队列。
（这个直接查看 ThreadPoolExecutor 的构造函数源码就可以看出，比较简单的原因，这⾥就不贴代码了）

public class corePoolsize {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service= Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        //设置线程池的属性
        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();
//        service1.setMaximumPoolSize();

        //2.执行指定的线程操作。需要提供实现Runnable接口或者Callable接口实现类的对象
        service.execute(new NumberThread());
        service.submit(new NumberThread1());
        
        //3.关闭连接池
        service.shutdown();
    }
}
class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class NumberThread1 implements Callable{

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
        return null;
    }
}

笨蛋悠米

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程（一）（创建多线程和线程常用方法、优先级等）

初识多线程进程可以细化为多个线程。每个线程，拥有自己独立的：栈、程序计数器多个线程，共享同一个进程中的结构：方法区、堆一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。并行与并发：并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事情。并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。多线程的创建，在jdk5之前有两种方法：方式一：继承于Thread类
复制链接

扫一扫