首页 > 编程语言 >Java学习——多线程

Java学习——多线程

时间：2024-07-22 22:41:16浏览次数：12  
标签：Java Thread void 学习 MyThread 线程 new 多线程 public

1.多线程介绍

1.1 什么是多线程

具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

1.2 并发与并行

  • 并行：在同一时刻，有多个指令在多个CPU上同时执行。
  • 并发：在同一时刻，有多个指令在单个CPU上交替执行。

高并发是什么意思：
image

cpu2核4线程表示可并行处理4个线程，当有更多的线程过来时，就会并发处理

2.线程实现方法

2.1 继承Thread类

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("helloWorld"+i);
        };
    }
}
public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 第一种实现线程的方法
        Thread thread1 = new MyThread();
        thread1.start();
}
}

注意， thread1.start()是开启线程，会执行run方法。
run()方法和start()方法的区别？

  • run()：封装线程执行的代码，直接调用，相当于普通方法的调用
  • start()：启动线程；然后由JVM调用此线程的run()方法

2.2 实现Runnable接口

实现步骤

  • 定义一个类MyRunnable实现Runnable接口
  • 在MyRunnable类中重写run()方法
  • 创建MyRunnable类的对象
  • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
  • 启动线程
public class MyRun implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        };
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // 第二种实现线程的方法
        MyRun run = new MyRun();
        // 第一个参数target – the object whose run method is invoked when this thread is started. If null, this thread's run method is invoked.
        Thread thread2 = new Thread(run, "thread2");
        thread2.start();
    }
}

2.3 实现Callable接口

实现步骤

  • 定义一个类MyCallable实现Callable接口
  • 在MyCallable类中重写call()方法
  • 创建MyCallable类的对象
  • 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
  • 创建Thread类的对象，把FutureTask对象作为构造方法的参数
  • 启动线程
  • 再调用get方法，就可以获取线程结束之后的结果。
public class MyCall implements Callable<Integer> {


    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum++;
        }
        return sum;
    }
}

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 第三种实现线程的方法 第三种是第一、二种的补充，可以返回结果
        MyCall call = new MyCall();
		// 该类用于传递线程参数，同时获取返回结果
        FutureTask<Integer> ft = new FutureTask<>(call);
        Thread thread3 = new Thread(ft);
        thread3.start();
        // 获取返回结果
        Integer i = ft.get();
        System.out.println("thread3 result:"+i);
    }
}

三种实现方式的对比

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

3.线程常用方法

3.1 name 方法介绍

方法名 说明
void setName(String name) 将此线程的名称更改为等于参数name
String getName() 返回此线程的名称
Thread currentThread() 返回对当前正在执行的线程对象的引用 
public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        //void setName(String name)：将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");

        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");

        my1.start();
        my2.start();

        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

上面的super方法是继承了父类中的构造方法，构造方法无法自动继承

3.2 sleep方法介绍

相关方法

方法名 说明
static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数 
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

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

3.3 线程优先级

线程调度

  • 两种调度方式

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

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

  • 优先级相关方法

方法名 说明
final int getPriority() 返回此线程的优先级
final void setPriority(int newPriority) 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 
public class ThreadDemo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // priority 线程优先级
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.setName("线程1");
        thread2.setName("线程2");

        // 获取线程优先级 默认是5
        System.out.println(thread1.getPriority());
        System.out.println(Thread.currentThread().getPriority());

        // 设置线程优先级  优先级只是扩大被执行的概率，不能一定说明线程会被首先执行
        thread1.setPriority(1);
        thread2.setPriority(10);

        thread1.start();
        thread2.start();
    }

优先级只是扩大被执行的概率，不能一定说明线程会被首先执行

3.4 守护线程

  • 相关方法
方法名 说明
void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出 
public class DaemonThread {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.setName("线程1");
        thread2.setName("线程2");
        // 设置线程2为守护线程  线程1结束后 线程2也会结束（注意不是立刻结束）
        thread2.setDaemon(true);

        thread1.setPriority(10);
        thread2.setPriority(1);

        thread1.start();
        thread2.start();
    }
}

上面开启线程2为守护线程，当线程1结束后，无论线程2是否运行完毕，线程2都会开始结束（不会立刻结束）。应用场景：线程2依赖于线程1的存在，例如QQ文件传输和QQ窗口启动，如果QQ窗口被关闭，文件传输也会关闭。

3.5 礼让线程

  • 相关方法
方法名 说明
public static native void yield() 执行当前线程时，出让cpu的执行权。不让当前线程霸占cpu执行，而是让cpu释放，进行下一次资源的争抢。注意下一次资源争抢当前线程仍有可能抢到 
public class MyYiled implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            // 执行当前线程时，出让cpu的执行权。不让当前线程霸占cpu执行，而是让cpu释放，进行下一次资源的争抢。
            // 下一次资源争抢当前线程仍有可能抢到
            Thread.yield();
        };
    }
}

这块不太清楚应用场景

3.6 插入线程

  • 相关方法
    执行当前线程时，出让cpu的执行权。不让当前线程霸占cpu执行，而是让cpu释放，进行下一次资源的争抢。注意下一次资源争抢当前线程仍有可能抢到
方法名 说明
void join() 表示在当前线程前插入执行 
public class JoinThread {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread1 = new MyThread();
        thread1.setName("线程1");

        thread1.start();
        // 让线程1插入到主线程之前执行
        thread1.join();

        // 当前在主线程的执行中
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

上述过程中，让线程1直接插入到主线程之前执行（jvm会执行main方法的线程），join()方法会让线程执行完毕后才执行下一个线程。也可以设置参数，设置执行该线程的最长执行时间

4.锁

4.1 案例引导

需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

  • 实现1
public class SellTask extends Thread{
    int tickets = 0;

    @Override
    public void run() {
        while (tickets < 100){
            try {
                sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            tickets++;
            System.out.println(Thread.currentThread().getName()+"卖出了第"+tickets+"张票");
        }
    }
}
  • 问题1：从运行结果来看，线程1、2、3之间没有共享tickets变量
    image
  • 解决1：将 int tickets = 0;改成static int tickets
  • 问题2：修改后，出现票号重复问题和票号过100问题
    image
    image
  • 解决2：出现该问题的原因是，线程控制权的随机性，线程的控制权随时发生变化，导致某个线程无法执行完所有过程就被其它线程抢占，导致了该问题
    解决方法是将卖票的逻辑上锁，使得操作共享变量的代码在任意时刻只能有一个线程执行
public class SellTask extends Thread{
    static int tickets = 0;
    // 锁对象 可以是任意对象
    static Object obj = new Object();

    @Override
    public void run() {
        synchronized (obj){ // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
            //t1进来后，就会把这段代码给锁起来
            while (tickets < 100){
                try {
                    sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                tickets++;
                System.out.println(Thread.currentThread().getName()+"卖出了第"+tickets+"张票");
            }
            //t1出来了，这段代码的锁就被释放了
        }
    }
}

public class SellThread {
    public static void main(String[] args) {
        SellTask thread1 = new SellTask();
        SellTask thread2 = new SellTask();
        SellTask thread3 = new SellTask();

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

运行结果：
image

注意：多个操作共享同一变量的线程之前应该使用同个锁。锁可以是任意对象。

标签：Java,Thread,void,学习,MyThread,线程,new,多线程,public
From： https://www.cnblogs.com/pengu1998/p/18297326

相关文章

  • 如何理解JAVA的编码格式是Unicode
    背景今天看以前的JAVA视频，发现课件里面写着JAVA的内部的编码格式是Unicode。这句话，突然勾起了我的好奇心。因为的JAVA代码文件都是UTF8编码，怎么跟Unicode扯上关系的呢？我去问了一下AI，然后整理了一下Unicode是JAVA编译器的读取class文件使用的编码假设，我的如下代码是UTF-8编......
  • java-cglib动态代理原理
    cglib使用1.引入依赖<!--添加cglib依赖--><dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version>&......
  • java编程 2
    1，比较运算符，比g和103是否相等？？？代码：publicclassbj{   publicstaticvoidmain(String[]args){       charq='g';       intw=103;       if(q==103){   System.out.println("g和103是相等的");       }else{......
  • Java编程 3
    1.轿车平均加速度   =速度的变化量/时间的变化量   轿车用了8.7秒从0千米加速到每小时100千米代码：publicclassvp{   publicstaticvoidmain(String[]args){   ints0=0;//定义变量值   ints1=(int)100.11;//浮点型强制转化成整型  ......
  • 嵌入式学习day05
    以下几个位置不允许创建文件和文件夹/:整个linux核心目录/home这里管理家目录，会危害用户数据/mnt/hgfs这个是挂载目录，以后所有的共享和外设都是挂载在这里虚拟机网络模式1.桥接模式网络相关ping语法：ping[选项]目标IP/目标网址说明：测试网络是否畅通执行者：所......
  • 使用Java和Flyway进行数据库版本控制
    使用Java和Flyway进行数据库版本控制大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天，我们来深入探讨如何使用Java和Flyway进行数据库版本控制。一、Flyway简介Flyway是一个数据库迁移工具，它能够帮助开发者管理数据库版本，自动应用数据库迁移脚本，确保......
  • Java中的元编程与动态代理技术
    Java中的元编程与动态代理技术大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天，我们将探讨Java中的元编程与动态代理技术。这些技术使得Java开发者能够在运行时动态地生成、修改代码或行为，增强了代码的灵活性和扩展性。一、元编程概述元编程（Metaprogr......
  • 使用Java和Spring Retry实现重试机制
    使用Java和SpringRetry实现重试机制大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天，我们将探讨如何在Java中使用SpringRetry来实现重试机制。重试机制在处理临时性故障和提高系统稳定性方面非常有用。一、SpringRetry简介SpringRetry是Spring框......
  • Java中的虚拟线程与并发编程优化
    Java中的虚拟线程与并发编程优化大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们将深入探讨Java中的虚拟线程及其对并发编程的优化。虚拟线程是Java21引入的一个新特性，它可以显著提高应用的并发性能，并简化线程的管理。我们将介绍虚拟线程的基本概......
  • 使用Java和Reactive Streams构建流式应用
    使用Java和ReactiveStreams构建流式应用大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天，我们将深入探讨如何使用Java和ReactiveStreams构建流式应用。流式应用能够高效处理异步数据流，尤其适合处理大量数据和实时数据的场景。ReactiveStreams是一个......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99