多线程(一)--多线程的概念及其基本使用

最新推荐文章于 2022-11-15 09:06:27 发布

平平无奇平平

最新推荐文章于 2022-11-15 09:06:27 发布

阅读量245

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_39188134/article/details/120737677

版权

多线程

1.1并发和并行

1.1并发和并行

并发：在同一时刻，有多个指令在单个CPU上交替执行。（注意：单个cpu执行多个指令）
并行：在同一时刻，有多个指令在多个cpu或者是多核的cpu同时执行。（注意：单个cpu执行单个指令）

当系统有一个以上CPU时,则线程的操作有可能非并发.当一个CPU执行一个线程时,另一个CPU可以执行另一个线程,两个线程互不抢占CPU资源,可以同时进行,这种方式我们称之为并行(Parallel)。

1.2进程和线程

进程：是正在运行的程序。
- 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。
- 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。
- 并发性：任何进程都可以同其他进程一起并发执行。
线程：是进程中的单个顺序控制流，是一条执行路径
- 单线程：一个进程如果只有一条执行路径，则称为单线程程序
- 多线程：一个进程如果有多条执行路径，则称为多线程程序

2.1 实现多线程方式

1.继承Thread类
2.实现Runnable接口
3.实现Callable接口

继承Thread类（无返回值）

方法介绍：

代码：

public class Thread01 extends Thread {
    @Override
    public void run() {
       for (int i=0;i<10000;i++){
           System.out.println(i);
       }
    }
}

创建多线程：

public class TestThread {

    public static void main(String[] args) {

        // 继承Thread类
        Thread01 t1 = new Thread01();
        Thread01 t2=new Thread01();

        //普通方法调用
       /* t1.run();
        t2.run();*/

       //开启多线程
        t1.start();
        t2.start();


    }
}

两个小问题：

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

实现Runnable接口（无返回值）

方法介绍：

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象，起一个名称

代码：

public class ThreadRunable implements Runnable {


    private  static  long time;

    @SneakyThrows //代替try{}catch{}捕捉异常
    @Override
    public void run() {


        for (int i=0;i<1000;i++){


           // System.out.println("线程休眠中。。。。。。。。。。。"+i);

            //线程休眠
            //Thread.sleep(100);

            System.out.println(i);

            System.out.println(Thread.currentThread());

        }



    }
}

创建多线程：

public class TestRunable {

    public static void main(String[] args) {

        ThreadRunable threadRunable = new ThreadRunable();

        Thread t1 = new Thread(threadRunable,"线程一");
        //Thread t1 = new Thread(threadRunable);
        //t1.setName("线程一");
        Thread t2 = new Thread(threadRunable,"线程二");

        t1.start();
        t2.start();
        //线程优先级 1-10 默认：5
        t1.setPriority(10);
        t2.setPriority(1);


    }



}

实现Callable接口（含有返回值）

方法介绍：

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()	如有必要，等待计算完成，然后获取其结果

代码：

public class ThreadCallable implements Callable {

    @Override
    public String call() throws Exception {
        for (int i=0;i<100;i++){
            System.out.println(i);
          //打印当前线程信息
            System.out.println(Thread.currentThread());
        }
        return "答应求婚";
    }
}

创建多线程：
public class TestCallable {

public static void main(String[] args) throws ExecutionException, InterruptedException {

    //线程开启之后需要执行里面的call方法
    ThreadCallable threadCallable1 = new ThreadCallable();
    //ThreadCallable threadCallable2 = new ThreadCallable();


    //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
    FutureTask<String> task1 = new FutureTask<String>(threadCallable1);
    FutureTask<String> task2 = new FutureTask<String>(threadCallable1);


    Thread t1 = new Thread(task1,"一次尝试");
    Thread t2 = new Thread(task2,"二次尝试");

    t1.start();
    t2.start();
    String s = task1.get();
    System.out.println("方法返回值："+s);
    System.out.println("当前运行线程的名称："+Thread.currentThread().getName());

}

}

三种实现方式的对比

实现Runnable、Callable接口
- 好处：扩展性强，实现该接口的同时还可以继承其他的类。
- 缺点：编程相对复杂，不能直接使用Thread类中的方法。
继承Thread类
- 好处: 编程比较简单，可以直接使用Thread类中的方法.
- 缺点: 可以扩展性较差，不能再继承其他的类.

2.2 多线程的其他操作

设置和获取线程名称

方法名	说明
static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数

public class TestThread {

    public static void main(String[] args) {
        // 继承Thread类
        Thread01 t1 = new Thread01();
        Thread01 t2=new Thread01();

		//设置线程名称
        t1.setName("线程一");

        //普通方法调用
       /* t1.run();
        t2.run();*/

       //开启多线程
        t1.start();
        t2.start();
//获取线程名称
 System.out.println(Thread.currentThread().getName());
    }
}

设置线程休眠

public class ThreadRunable implements Runnable {


    private  static  long time;

    @SneakyThrows //代替try{}catch{}捕捉异常
    @Override
    public void run() {


        for (int i=0;i<1000;i++){
            //线程休眠
            Thread.sleep(100);
            System.out.println(i);
            
        }
    }
}

设置线程优先级

线程调度分为两种方式：
- 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片。
- 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。

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

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

public class TestRunable {

    public static void main(String[] args) {

        ThreadRunable threadRunable = new ThreadRunable();

        Thread t1 = new Thread(threadRunable);
        t1.setName("线程一");

        Thread t2 = new Thread(threadRunable,"线程二");

        t1.start();
        t2.start();
        //线程优先级 1-10 默认：5
        t1.setPriority(10);
        t2.setPriority(1);
		//获取线程优先级
        int priority = t1.getPriority();
        System.out.println("获取优先级："+priority);


    }



}

设置守护线程

方法名	说明
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出。

注意：守护线程应当在线程开始前设置！！！！！你不能把正在运行的常规线程设置为守护线程。

public class TestRunable {

    public static void main(String[] args) {

        ThreadRunable threadRunable = new ThreadRunable();

        Thread t1 = new Thread(threadRunable);
        t1.setName("线程一");

        Thread t2 = new Thread(threadRunable,"线程二");
 //设置为守护线程 需要在线程开始前设置
        t2.setDaemon(true);
        t1.start();
        t2.start();
 
      



    }



}

平平无奇平平

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程(一)--多线程的概念及其基本使用

多线程1.1并发和并行1.2进程和线程2.1 实现多线程方式继承Thread类（无返回值）实现Runnable接口（无返回值）实现Callable接口（含有返回值）三种实现方式的对比2.2 多线程的其他操作设置和获取线程名称设置线程休眠设置线程优先级设置守护线程1.1并发和并行并发：在同一时刻，有多个指令在单个CPU上交替执行。（注意：单个cpu执行多个指令）并行：在同一时刻，有多个指令在多个cpu或者是多核的cpu同时执行。（注意：单个cpu执行单个指令）当系统有一个以上CPU时,则线程的操作
复制链接

扫一扫