线程java代码实例[7个例子]

最新推荐文章于 2024-07-08 10:57:58 发布
原创 最新推荐文章于 2024-07-08 10:57:58 发布 · 4.7k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了Java线程的创建和应用，包括通过继承Thread类和实现Runnable接口两种方式创建线程，线程参数传递，线程共享资源，以及多个线程同步的例子。例如，模拟3个站台售票、线程间同步控制取款和龟兔赛跑等，深入理解Java线程的关键概念和实践技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

例子部分参考验证：
https://blog.csdn.net/qq_34996727/article/details/80416277?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-3.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-3.channel_param

1 实现线程执行单元
把标题从 1 创建线程 更新为 1 实现线程执行单元的方式。
java中只有Thread代表线程。Runnable只是将业务相关的代码抽象为一个接口。这涉及到一种设计模式：策略模式。
因此创建线程new线程的方式只有一种。
实现线程执行单元线程体的方式有两种。
例1.继承Thread类方式
代码：

package com.whl.thread;

/**
 * 注:
 * java.lang包中放着java最核心最基础的类、接口：Object、System、Thread、Runnable
 * Thread.currentThread()获取当前cpu执行线程
 */
public class TestThread {
    public static void main(String[] args) {
        /**
         * step 3：在方法中新建一个刚才写的类
         */
        MyThread myThread = new MyThread();// 线程处于新建状态
        myThread.start();// 就绪状态
        for(int i = 0;i < 10;i++) {
            System.out.println("hello "+Thread.currentThread().getName());
        }
    }
}

/**
 * step 1：写一个类继承java.lang.Thread
 */
class MyThread extends Thread {
    /**
     * step 2:复写java.lang.Thread中的run()方法
     */
    @Override
    public void run() {// 运行
        // TODO 你的线程代码
        for(int i = 0;i < 10;i++) {
            System.out.println("hello "+Thread.currentThread().getName());
        }
    }
}

运行结果：
在这里插入图片描述
例2.实现Runnable接口方式
代码

package com.whl.thread;

public class TestThread2 {
    public static void main(String[] args) {
        /**
         * step 3:创建实现类
         */
        MyRunnable myRunnable = new MyRunnable();
        /**
         * step 4:创建Thread，传入实现类
         */
        Thread thread = new Thread(myRunnable);
        /**
         * step 5:调用start（）方法
         */
        thread.start();
        for(int i = 0;i < 10;i++) {
            System.out.println("hello "+Thread.currentThread().getName());
        }
    }
}

/**
 * step 1:写一个Runnable接口的实现类
 */
class MyRunnable implements Runnable {
    /**
     * step 2:实现Runnable接口run（）
     */
    @Override
    public void run() {
        for(int i = 0;i < 10;i++) {
            System.out.println("hello "+Thread.currentThread().getName());
        }
    }
}

运行结果
在这里插入图片描述
2 线程参数传递
例3.在实现类或继承类中写局部变量，通过有参构造、setget方式获取参数。
代码

package com.whl.thread;

public class TestThread3 {
    public static void main(String[] args) {
        /**
         * step 3：创建线程，创建实现类中传递实参
         */
        Thread t1 = new Thread(new MyRunnable2(23));
        t1.start();
        int i = 6;
        while(i-- > 0){
            System.out.println(Thread.currentThread().getName());
        }
    }
}
class MyRunnable2 implements Runnable {
    /**
     * step 1:在实现类中定义局部变量
     */
    private int age;

    /**
     * step 2:定义有参构造方法
     * @param age
     */
    public MyRunnable2(int age) {
        this.age = age;
    }
    @Override
    public void run() {
        int i = 6;
        while(i-- > 0){
            /**
             * step 4:使用参数
             */
            System.out.println(Thread.currentThread().getName() + " 我的年龄是->" + age);
        }
    }
}

运行结果
在这里插入图片描述
使用实现Runnable接口方式更好，原因：
java是单继承多实现；共享资源；数据和程序独立；
例4.两个线程共享资源实现代码：

package com.whl.thread;

public class TestThread3 {
    public static void main(String[] args) {
        MyRunnable2 myRunnable2 = new MyRunnable2();
        myRunnable2.setAge(23);
        // 两个线程共享变量age
        Thread t1 = new Thread(myRunnable2);
        Thread t2 = new Thread(myRunnable2);
        t1.start();
        t2.start();
        int i = 10;
        while(i-- > 0) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}
class MyRunnable2 implements Runnable {
    /**
     * step 1:在实现类中定义局部变量
     * 两个线程共享
     */
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public void run() {
        int i = 10;
        while(i-- > 0){
            this.age++;
            System.out.println(Thread.currentThread().getName() + " 我的年龄是->" + age);
        }
    }
}

运行结果：
在这里插入图片描述
3 线程应用例子
例5. 3个站台同时出售火车票，火车票共有20张
代码实现：

package com.whl.example.station;

/**
 * 注明：
 * static： 在类中的类前加上static，直接通过类名.类名调用；
 *          在类中的方法前加上static，直接通过类名.方法名调用；
 *          在类中的变量前加上static，直接同多类名.变量名访问；
 * 静态变量生命周期是类的生命周期；
 *
 * step 1: 创建一个站台类继承java.lang.Thread
 */
public class Station extends Thread {
    /**
     * step 2: 创建有参构造方法，给线程名称赋值
     * @param name
     */
    public Station(String name) {
        super(name);
    }
    /**
     * step 3：创建静态变量，类的变量
     */
    static int tick = 20;
    /**
     * step 4: 创建静态钥匙，类的变量
     *
     * 关键思想：通过[静态，没有static关键字可正常运行]变量的占用判断是否对另一个静态变量操作
     */
     Object lock = "one";

    /**
     * step 5: 重写run()方法，实现买票操作
     */
    @Override
    public void run() {
        while(tick > 0) {
            /**
             * step 6: 每个线程使用同一静态变量，一个线程占用该静态变量时，其他线程不允许进入
             *          该线程出来这个代码块后，不使用该静态变量
             *
             * 关键思想：synchronized与静态变量lock配合，操作系统保证cpu只运行三个线程中唯一一个线程中此段代码，
             *           其他线程不能被执行。唯一一个线程的此段代码运行结束后，cpu可同步执行3个线程线程。
             */
            synchronized (lock) {
                if(tick > 0) {
                    System.out.println(getName()+"卖出了第"+tick+"张票");
                    tick--;
                }else {
                    System.out.println("票卖完了");
                }
            }
            try {
                sleep(500);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
}



package com.whl.example.station;

public class Main {
    public static void main(String[] args) {
        /**
         * step 7: 创建继承类售票窗口
         *          3个窗口
         */
        Thread t1 = new Station("售票窗口1号");
        Thread t2 = new Station("售票窗口2号");
        Thread t3 = new Station("售票窗口3号");
        /**
         * step 8: 三个窗口都处于就绪状态
         */
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：
在这里插入图片描述问题：同步关键字为什么不写在循环外？
同步关键字写在循环外面代码：

@Override
public void run() {
    synchronized (lock){while(tick > 0) {
        /**
         * step 6: 每个线程使用同一静态变量，一个线程占用该静态变量时，其他线程不允许进入
         *          该线程出来这个代码块后，不使用该静态变量
         *
         * 关键思想：synchronized与静态变量lock配合，操作系统保证cpu只运行三个线程中唯一一个线程中此段代码，
         *           其他线程不能被执行。唯一一个线程的此段代码运行结束后，cpu可同步执行3个线程线程。
         */

            if(tick > 0) {
                System.out.println(getName()+"卖出了第"+tick+"张票");
                tick--;
            }else {
                System.out.println("票卖完了");
            }

        try {
            sleep(500);
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}}

运行结果：
在这里插入图片描述
结论：同步关键字修饰的代码块，被单独执行。
例6.两个人，一个人每次取钱100元，一个人每次取钱200元，账户里有1000元.
代码实现：

package com.whl.example.person;

import java.util.Objects;

/**
 * step 1:创建银行类
 */
public class Bank {
    /**
     * 创建一个账户，放1000元
     * [有没有 static 不影响结果]
     */
    double money = 1000;

    /**
     * 提供柜台取钱方法
     * @param money
     */
    private void counter(double money) {
        this.money -= money;
        System.out.println("柜台取钱"+money+"元，还剩"+this.money+"元！");
    }

    /**
     * 提供atm取钱方法
     * @param money
     */
    private void atm(double money) {
        this.money -= money;
        System.out.println("atm取钱"+money+"元，还剩"+this.money+"元！");
    }

    /**
     * 核心：只要有一个线程被cpu正在执行这个取钱方法，其他都不准执行。
     *
     * 提供取钱方法，设置每次取钱金额，取钱方式
     * @param money
     * @param mode
     * @throws Exception
     */
    public synchronized void outMoney(double money,String mode) throws Exception {
        if(money > this.money) {
            throw new Exception("取款金额"+money+",余额只剩"+this.money+",取款失败！");
        }
        if(Objects.equals(mode,"atm")) {
            atm(money);
        }else {
            counter(money);
        }
    }
}


package com.whl.example.person;

/**
 * step 2：创建一个人继承java.lang.Thread
 */
public class PersonA extends Thread {
    Bank bank;
    String mode;
    public PersonA(Bank bank,String mode) {
        this.bank = bank;
        this.mode = mode;
    }

    /**
     * 每次取钱100，柜台取钱
     */
    public void run(){
        while(bank.money >= 100) {
            try{
                bank.outMoney(100,mode);
            }catch (Exception e) {
                e.printStackTrace();
            }
            try{
                sleep(100);
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


package com.whl.example.person;
/**
 * step 3：创建一个人继承java.lang.Thread
 */
public class PersonB extends Thread {
    /**
     * 创建账户
     */
    Bank bank;
    /**
     * 创建取钱方式
     */
    String mode;

    /**
     * 提供设置具体取钱方式及账户的方法
     * @param bank
     * @param mode
     */
    public PersonB(Bank bank,String mode) {
        this.bank = bank;
        this.mode = mode;
    }

    /**
     * 每次取钱200元，atm取钱
     */
    public void run(){
        while(bank.money >= 200) {
            try{
                bank.outMoney(200,mode);
            }catch (Exception e) {
                e.printStackTrace();
            }
            try{
                sleep(100);
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


package com.whl.example.person;

/**
 * step 4:创建一个入口类
 */
public class Main {
    public static void main(String[] args) {
        /**
         * 实例化一个银行账户
         */
        Bank bank = new Bank();
        /**
         * 实例化两个继承类，共享这个银行账户
         */
        PersonA personA = new PersonA(bank,"counter");
        PersonB personB = new PersonB(bank,"atm");
        /**
         * 线程处于就绪状态
         */
        personA.start();
        personB.start();
    }
}

运行结果：
在这里插入图片描述
例7.龟兔赛跑
总共200米
乌龟0.1秒跑2米，不休息
兔子0.1秒跑5米，每20米休息1秒
一个赢了，另一个停止跑
实现代码：

package com.whl.example.animal;

public abstract class Animal extends Thread {
    /**
     * 比赛长度
     */
    public int length = 200;

    /**
     * 抽象方法
     * 动物跑
     */
    public abstract void running();

    /**
     * 复写run（）
     */
    public void run(){
        super.run();
        while (length > 0) {
            running();
        }
    }

    /**
     * 抽象类中声明一个接口
     */
    public static interface Calltoback {
        public void win();
    }
    /**
     * 创建接口对象
     */
    public Calltoback calltoback;
}


package com.whl.example.animal;

public class Rabbit extends Animal {
    public Rabbit() {
        setName("兔子");
    }

    @Override
    public void running() {
        int dis = 5;
        length -= dis;
        System.out.println("兔子跑了"+dis+"米，距离终点还有"+length+"米");
        if(length <= 0) {
            length = 0;
            System.out.println("兔子赢了！");
            // 给回调对象赋值，让乌龟不要跑了
            if(calltoback != null) {
                calltoback.win();
            }
        }
        try {
            if((2000 - length) % 20 == 0) {// 每20米休息一次
                sleep(1000);
            }else {
                sleep(100);// 每0.1秒跑5米
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}


package com.whl.example.animal;

public class Tortoise extends Animal {
    public Tortoise() {
        setName("乌龟");
    }
    @Override
    public void running() {
        int dis = 2;
        length -= dis;
        System.out.println("乌龟跑了"+dis+"米，距离终点还有"+length+"米");
        if(length <= 0) {
            length = 0;
            System.out.println("乌龟赢了！");
            if(calltoback != null) {
                calltoback.win();
            }
        }
        try {
            sleep(100);// 跑2米停0.1秒 -> 每0.1秒跑2米
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}


package com.whl.example.animal;

public class LetOneStop implements Animal.Calltoback {
    Animal animal;
    public LetOneStop(Animal animal) {
        this.animal = animal;
    }
    public void win(){
        // 线程停止
        animal.stop();
    }
}


package com.whl.example.animal;

public class Main {
    public static void main(String[] args) {
        // 乌龟
        Tortoise tortoise = new Tortoise();
        // 兔子
        Rabbit rabbit = new Rabbit();
        // 兔子赢了，将乌龟停止
        LetOneStop letOneStop1 = new LetOneStop(tortoise);
        rabbit.calltoback = letOneStop1;
        // 乌龟赢了，将兔子停止
        LetOneStop letOneStop2 = new LetOneStop(rabbit);
        tortoise.calltoback = letOneStop2;
        // 跑
        tortoise.start();
        rabbit.start();
    }
}

运行结果：
在这里插入图片描述

Java 线程简单示例
啸铁
09-25 424
Java 线程可以通过 extends Thread 类来实现，也可以 implements Runnable 接口来实现。 示例 下面的例子分别给出了通过 extends Thread 和 implements Runnable 来实现线程的例子。可以看出，无论哪种方法，都要实现 public static void run() 方法，调用时先 new Runner() 或 new ExtendsThread，然后将 new 出的对象传入Thread(), 构造一个 Thread 对象, 调用 Threa
Java实例——线程
Zain_horse的博客
02-23 708
Java实例——线程
java多线程示例
03-02
Java中的多线程有三种实现方式： 1.继承Thread类，重写run方法。Thread本质上也是一个实现了Runnable的实例，他代表一个线程的实例，并且启动线程的唯一方法就是通过Thread类的start方法。 2.实现Runnable接口，并实现该接口的run()方法.创建一个Thread对象，用实现的Runnable接口的对象作为参数实例化Thread对象，调用此对象的start方法。 本示例演示和wait和sleep、线程锁的使用。
java 线程的例子_java多线程例子
weixin_42374582的博客
02-25 179
到这里我们做一个完整的例子来说明线程产生的方式不同而生成的线程的区别：package debug;import java.io.*;import java.lang.Thread;class MyThread extends Thread{public int x = 0;public void run(){System.out.println(++x);}}class R implements ...
java常用多线程示例_java多线程的常见例子
weixin_42498892的博客
02-13 1429
java多线程的常见例子一.相关知识：Java多线程程序设计到的知识：(一)对同一个数量进行操作(二)对同一个对象进行操作(三)回调方法使用(四)线程同步，死锁问题(五)线程通信等等二．示例一：三个售票窗口同时出售20张票;程序分析：1.票数要使用同一个静态值2.为保证不会出现卖出同一个票数，要java多线程同步锁。设计思路：1.创建一个站台类Station，继承Thread，重写run方法，在r...
java 线程锁详细介绍及实例代码
08-31
在这个例子中，`Window`类的每个实例都有自己的线程，它们共享同一个锁对象`obj`。当一个线程进入同步代码块并持有锁后，其他线程必须等待锁被释放才能继续执行。 四、线程锁的注意事项 1. 死锁：多个线程相互等待...
Java多线程实例
09-03
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承`java.lang.Thread`类或实现`java.lang.Runnable`接口。 1. 继承Thread...
Java编程一道多线程问题实例代码
08-28
Java编程中的多线程问题实例主要探讨如何高效地利用多线程处理任务，这里通过一个模拟打印日志的场景来阐述。题目要求处理16条日志记录，每条记录打印耗时1秒，目标是在4秒内完成全部打印工作，通过开启4个线程来...
Java中线程休眠编程实例
09-03
在提供的代码实例中，`SleepMethodTest` 类创建了一个新的线程，该线程不断地在窗口上绘制随机颜色的线段。这个过程展示了`Thread.sleep()`方法的使用以及如何与其他线程方法配合工作。 首先，我们看`Thread.sleep...
Java实现多线程断点下载实例代码（下载过程中可以暂停）
08-31
以下是一个简单的多线程断点下载的Java代码实例： ```java import java.io.*; // ...其他导入 public class DownLoad { // 下载URL public static final String PATH = ...
java 线程池示例（自己实现的参考别人的代码）
04-10
NULL 博文链接：https://yulincqupt.iteye.com/blog/1673919
java线程实例 各种小Demo
04-24
java中各种类型的线程实例,小Demo
java多线程经典案例
01-15
java多线程经典案例，线程同步、线程通信、线程阻塞等经典案例
Java中多线程经典案例
最新发布
2301_79288225的博客
07-08 3069
相反懒汉模式则会引起线程不安全,因为懒汉模式是在有需要的时候才会去实例化对象,在多线程编程中懒汉模式要进行读和写操作,这一修改变量的值不是原子的,所有会造成线程不安全的问题,因此我们要使用synchronized对读和写操作进行加锁,打包成一个原子的操作,加锁会影响性能的问题,如果是第一次判断instance是否为空则需要加锁,若后续第二次...等,每次加锁都势必会影响性能问题,因此我们可以考虑在加一个if判断。
java多线程示例_Java线程示例
从零开始的教程世界
07-17 286
java多线程示例Welcome to the Java Thread Example. Process and Thread are two basic units of execution. Concurrency programming is more concerned with java threads. 欢迎使用Java线程示例。 进程和线程是执行的两个基本单元。 并发编程更关注Jav...
Java线程方式及实例
qq_41706745的博客
09-15 191
线程创建方式由继承Thread类，实现Runnable接口，实现Callable接口通过FutureTask包装，通过线程池来创建 继承Thread类 Thread本质是实现Runnable接口的一个实例。实现如下： 线程 /** - 继承Thread类创建线程 */ public class MyThread extends Thread { /** * 重写run（）方法来实现自己的业务需求 */ @Override public void ru.
Java多线程（案例+解析
2401_84049001的博客
04-09 1111
至此，文章终于到了尾声。技术能力：先写岗位所需能力，再写加分能力，不要写无关能力；项目经历：只写明星项目，描述遵循 STAR 法则；简历印象：简历遵循三大原则：清晰，简短，必要，要有的放矢，不要海投；以及最后为大家准备的福利时间：简历模板+Java面试题+热门技术系列教程视频《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />至此，文章终于到了尾声。技术能力：先写岗位所需能力，再写加分能力，不要写无关能力；
java多线程例子_java 多线程简单例子
weixin_30717229的博客
02-12 2557
实现线程的方式是一，继承Thread类，重写父类的run()方法二，实现接口Runnable中的run()方法。下面是简单的例子例子1：银行存取钱问题package com.direct.demo;public class Bank {private static int money;public int getMoney(){return money;}public void saveMoney...
Java线程编程实践：18个经典例子解析
在“java线程例子大全”的例子代码中，应该包含了这些知识点的具体实践和详细解释，以便开发者通过实例学习并掌握Java多线程编程的各个方面。这些例子能够帮助初学者从理论到实践，逐步深入理解并运用Java线程，为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值