java——多线程

最新推荐文章于 2021-10-21 21:35:11 发布

kerve

最新推荐文章于 2021-10-21 21:35:11 发布

阅读量92

点赞数

分类专栏： java 文章标签： java 多线程

抚琴

本文链接：https://blog.csdn.net/qq_42186263/article/details/113119073

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

引言

随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。

进程与线程

程序，进程，线程的基本概念+并行与并发：
程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。
进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。-------生命周期
线程：进程可进一步细化为线程，是一个程序内部的一条执行路径
即：线程《线程（一个程序可以有多个线程）
程序：静态的代码进程：动态执行的程序
线程：进程中要同时干几件事时，每一件事的执行路径成为线程。

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

线程的相关API

//获取当前线程的名字
Thread.currentThread().getName()

1.start():1.启动当前线程2.调用线程中的run方法
2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3.currentThread():静态方法，返回执行当前代码的线程
4.getName():获取当前线程的名字
5.setName():设置当前线程的名字
6.yield():主动释放当前线程的执行权
7.join():在线程中插入执行另一个线程，该线程被阻塞，直到插入执行的线程完全执行完毕以后，该线程才继续执行下去
8.stop():过时方法。当执行此方法时，强制结束当前线程。
9.sleep（long millitime）：线程休眠一段时间
10.isAlive（）：判断当前线程是否存活

多线程的创建方式

1. 方式1：继承于Thread类

1.创建一个集成于Thread类的子类 （通过ctrl+o（override）输入run查找run方法）
2.重写Thread类的run（）方法
3.创建Thread子类的对象
4.通过此对象调用start（）方法

start与run方法的区别：
start方法的作用：1.启动当前线程 2.调用当前线程的重写的run方法（在主线程中生成子线程，有两条线程）
调用start方法以后，一条路径代表一个线程，同时执行两线程时，因为时间片的轮换，所以执行过程随机分配，且一个线程对象只能调用一次start方法。
run方法的作用：在主线程中调用以后，直接在主线程一条线程中执行了该线程中run的方法。（调用线程中的run方法，只调用run方法，并不新开线程）

总结：我们不能通过run方法来新开一个线程，只能调用线程中重写的run方法（可以在线程中不断的调用run方法，但是不能开启子线程，即不能同时干几件事），start是开启线程，再调用方法（即默认开启一次线程，调用一次run方法，可以同时执行几件事）
看这个例子：

package andoridjimi;
public class window extends Thread{
    private int ticket = 100; //将其加载在类的静态区，所有线程共享该静态变量
    private  int a;
    @Override
    public void run() {
        while(true){

            if(ticket>0){


                System.out.println(getName()+"当前售出第"+ticket+"张票");
                ticket--;

            }else{
                break;
            }
        }
    }
}

public class cc {

    //主方法
    public static void main(String[] args) {

            window t1 = new window();
            window t2 = new window();
            window t3 = new window();

            t1.setName("售票口1");
            t2.setName("售票口2");
            t3.setName("售票口3");

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

. 方式2：实现Runable接口方式

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

package andoridjimi;
public class window implements Runnable {
    private int ticket = 100; //将其加载在类的静态区，所有线程共享该静态变量
    private  int a;
    @Override
    public void run() {
        while(true){

            if(ticket>0){


                System.out.println(Thread.currentThread().getName()+"当前售出第"+ticket+"张票");
                ticket--;

            }else{
                break;
            }
        }
    }
}

public class cc {

    //主方法
    public static void main(String[] args) {

            window t1 = new window();
            window t2 = new window();
            window t3 = new window();

            t1.setName("售票口1");
            t2.setName("售票口2");
            t3.setName("售票口3");

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

比较创建线程的两种方式：
开发中，优先选择实现Runable接口的方式
原因1：实现的方式没有类的单继承性的局限性
2：实现的方式更适合用来处理多个线程有共享数据的情况
联系：Thread也是实现自Runable，两种方式都需要重写run（）方法，将线程要执行的逻辑声明在run中

新增的两种创建多线程方式

1.实现callable接口方式

：
与使用runnable方式相比，callable功能更强大些：
runnable重写的run方法不如callaalbe的call方法强大，call方法可以有返回值
方法可以抛出异常
支持泛型的返回值
需要借助FutureTask类，比如获取返回结果

package com.example.paoduantui.Thread;


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 创建线程的方式三：实现callable接口。---JDK 5.0新增
 *是否多线程？否，就一个线程
 *
 * 比runable多一个FutureTask类，用来接收call方法的返回值。
 * 适用于需要从线程中接收返回值的形式
 * 
 * //callable实现新建线程的步骤：
 * 1.创建一个实现callable的实现类
 * 2.实现call方法，将此线程需要执行的操作声明在call（）中
 * 3.创建callable实现类的对象
 * 4.将callable接口实现类的对象作为传递到FutureTask的构造器中，创建FutureTask的对象
 * 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法启动（通过FutureTask的对象调用方法get获取线程中的call的返回值）
 * 
 * */


//实现callable接口的call方法
class NumThread implements Callable{

    private int sum=0;//

    //可以抛出异常
    @Override
    public Object call() throws Exception {
        for(int i = 0;i<=100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {

    public static void main(String[] args){
        //new一个实现callable接口的对象
        NumThread numThread = new NumThread();

        //通过futureTask对象的get方法来接收futureTask的值
        FutureTask futureTask = new FutureTask(numThread);

        Thread t1 = new Thread(futureTask);
        t1.setName("线程1");
        t1.start();

        try {
            //get返回值即为FutureTask构造器参数callable实现类重写的call的返回值
           Object sum = futureTask.get();
           System.out.println(Thread.currentThread().getName()+":"+sum);
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

使用线程池的方式：
背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池之，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具。（数据库连接池）
好处：提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
。。。。。。

JDK 5.0 起提供了线程池相关API：ExecutorService 和 Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor.
void execute(Runnable coommand):执行任务/命令，没有返回值，一般用来执行Runnable
Futuresubmit(Callable task):执行任务，有返回值，一般又来执行Callable
void shutdown（）：关闭连接池。
在这里插入图片描述

package com.example.paoduantui.Thread;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 创建线程的方式四：使用线程池（批量使用线程）
 *1.需要创建实现runnable或者callable接口方式的对象
 * 2.创建executorservice线程池
 * 3.将创建好的实现了runnable接口类的对象放入executorService对象的execute方法中执行。
 * 4.关闭线程池
 *
 * */

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 Runnable{
    @Override
    public void run() {
        for(int i = 0;i<100; i++){
            if(i%2==1){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args){

        //创建固定线程个数为十个的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        //new一个Runnable接口的对象
        NumberThread number = new NumberThread();
        NumberThread1 number1 = new NumberThread1();

        //执行线程,最多十个
        executorService.execute(number1);
        executorService.execute(number);//适合适用于Runnable

        //executorService.submit();//适合使用于Callable
        //关闭线程池
        executorService.shutdown();
    }

}