Java多线程的练习

最新推荐文章于 2025-04-06 09:40:22 发布
最新推荐文章于 2025-04-06 09:40:22 发布
阅读量843 收藏 3
点赞数
分类专栏： JavaSE 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Seven597/article/details/115414435
版权

Java的多线程

线程类的部分方法

有关方法1

void start() : 启动线程并执行run()
run() : 线程被调度时执行的操作
String getName(): 放回当前线程的名字
void setName(): 设置当前线程的名字
static Thread currentThread(): 返回当前线程， 在Thread子类中就是 this, 通常用于主线程和Runnable实现类

有关方法而2

static void yield() : 线程让步， 暂停当前正在执行的线程，把执行的机会让给优先级相同或者更高的线程， 若队列里没有优先级更高的线程，忽略此方法
join() : 阻塞当前线程，join()其他线程，当加入的线程执行完后，此线程才会继续
static void sleep(long millis) : (指定时间毫秒): 是令当前的活动线程再指定时间内放弃对cup的控制，使其他的线程有机会被执行，时间到后重新排队；抛出InterruptedException异常

创建线程

第一种创建线程的方式 (继承Thread)

/**

  • 多线程的创建， 方式一 继承于 Thread类
    1. 创建一个继承于 Thread的子类
    1. 重写Thread类的run()
    1. 创建继承于Thread类的子类的对象
    1. 通过此对象调用 start()
      */

创建线程类

// 1. 创建一个继承于 Thread的子类
class  MyThread extends Thread {
    String flag;

    public MyThread(String flag) {
        this.flag = flag;
    }

    // 2. 重写Thread类的run()
    @Override
    public void run() {
        for (int i=0; i<100; i++) {
            if(i%2==0) {
                System.out.println(i + this.flag + Thread.currentThread().getName());
            }
        }
    }
}

使用线程

public class Thread01 {
    public static void main(String[] args) {

        // 3. 创建继承于Thread类的子类的对象
        MyThread m1 = new MyThread("*****线程1*****");
        // 4. 通过此对象调用  start()  ①： 启动当前线程  ②： 调用当前线程的run()
        m1.start();
    }
}

使用匿名类创建 线程

new Thread() {
            @Override
            public void run() {
                for (int i=0; i<100; i++) {
                    System.out.println(i + Thread.currentThread().getName());
                }
            }
        }.start();

第二种创建线程的方式 （实现 Runnable）

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

代码实现

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


public class Thread03 {
    public static void main(String[] args) {
        // 3. 创建实现类对象
        MThread mm = new MThread();
        //  4. 将此对象作为参数传递到Thread类的构造器中， 创建Thread的对象
        Thread t1 = new Thread();

        // 5. 通过Thread类的对象调用start() 方法
        t1.start();
    }

}



//1. 创建一个实现  Runnable接口的类
class MThread implements Runnable {
    //2. 实现类去实现抽象方法 run()
    @Override
    public void run() {
        for (int i=100; i<100; i++) {
            System.out.println(i);
        }
    }
}

分析两种线程的创建

开发中优先选择实现 Runnable接口的方式
原因：
1.实现的方式没有类的单继承的局限性
2.实现的方式更合适处理有共享数据的情况

第三种创建线程（实现Callable接口）

此创建 方法 可以 有返回值（object类型），通过重写 call 。可以抛出异常。
如果想要接收返回值，需要借助FutureTask， 通过此对象的get() 方法获取。
需要通过 new Thread(futureTask).start() 将线程跑起来。

代码如下：

package jzq.com.Thread11;

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

public class THread11 {
    public static void main(String[] args) {
        MyThread mm = new MyThread();

        // 获取该线程的返回值 （通过 get() ）
        FutureTask futureTask = new FutureTask(mm);

        // 启动线程
        new Thread(futureTask).start();
        try {
            Object sum = futureTask.get();
            System.out.println(sum);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}



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

线程池的使用 (ExecutorService)

创建线程池： ExecutorService service = Executors.newFixedThreadPool(10);
线程池跑 线程：
service.execute(new MThread2());// execute 适合于 Runnable
service.submit(futureTask); // submit 适合 Callable
关闭线程池:
service.shutdown()

测试代码如下：

package jzq.com.Thread12;

import java.util.concurrent.*;

public class Thread13 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);

        //  execute 适合于  Runnable
        service.execute(new MThread2());
        service.execute(new MThread2());

        // 接收返回值
        MyThread1 mm = new MyThread1();
        FutureTask futureTask = new FutureTask(mm);


        // submit 适合 Callable
        service.submit(futureTask);
        service.submit(new MyThread1());

    }
}



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

class MThread2 implements Runnable {
    //2. 实现类去实现抽象方法 run()
    @Override
    public void run() {
        for (int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName() + ":(Runnable)" + i);
        }
    }
}

线程的优先级

优先级

MAX_PRIORITY: 10
MIN_PRIORITY: 1
NPRMPRIORITY: 5 (默认优先级)

设置以及获取优先级的方法

  1. getpriority() : 获取当前线程的优先级
  2. setpriority(int p) : 设置当前线程的优先级

线程的生命周期

图解线程的生命周期（参考尚硅谷视频）

在这里插入图片描述

线程的同步

同步的优缺点

优点

解决了线程的安全性问题

缺点

操作同步代码的时候，只能有一个线程参与，其他线程等待，相当于一个线程操作，效率低。有局限性！

同步代码块

synchronized (同步监视器) {// 需要被同步的代码}
说明：

  1. 操作共享数据的代码，即为需要被同步的代码，测试的时候如果拿循环来测试，一定要在循环体内, 不然就成为单线程了
  2. 共享数据， 多个线程共同操作的变量
  3. 同步监视器， 俗称：锁。 任何一个类的对象都可以叫锁。 但是这个吧锁要是唯一的，不然会出现线程的安全性问题。

代码如下：

package jzq.com.Thread04;

public class Thread04 {
    public static void main(String[] args) {
        MyThread mm = new MyThread();
        Thread t1 = new Thread(mm);
        Thread t2 = new Thread(mm);

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

}



class MyThread implements Runnable {
    private int s = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized(MyThread.class) {
                if (s<0) {
                    break;
                }else {
                    try {
                        Thread.sleep(100);
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"当前售票" + s);
                    s--;
                }
            }
        }

    }
}

同步方法

将同步的代码封装到方法，此方法被synchronized 所修饰

代码如下：

public synchronized void show() {
        if (s>0) {
            try {
                Thread.sleep(100);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"当前售票" + s);
            s--;
        }
    }

当使用 继承Thread的线程实现抢票功能时注意问题

变量值

注意值一定要是静态的，不然就是三个线程使用的不同的资源。

使用同步代码块或者同步方法的时需要注意

同步代码块，所添加的锁（同步监视器），一定是一个对象，可以是静态的对象或者class
同步方法一定要声明静态，不然自动获取的锁不是唯一的，也会出现安全性问题。

代码如下

package jzq.com.Thread05;

public class Thread05 {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        MyThread m2 = new MyThread();
        MyThread m3 = new MyThread();


        m1.start();
        m2.start();
        m3.start();

    }
}


class MyThread extends Thread {
    private static int s = 100;

    @Override
    public void run() {
        while (true) {
//            synchronized (MyThread.class) {
//                if(s>0) {
//                    try {
//                        Thread.sleep(100);
//                    }catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//
//                    System.out.println(Thread.currentThread().getName() + "抢票中---" + s);
//                    s--;
//                }
//            }
            show();
        }
    }

    public synchronized static void show() {
        if(s>0) {
            try {
                Thread.sleep(100);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "抢票中---" + s);
            s--;
        }
    }
}

使用 ReentrantLock 线程锁解决同步带来的安全性问题

创建 一个ReentrantLock 对象，通过 此对象调用lock()：锁定方法 与 unlock(): 解锁方法进行控制，开锁后的同步代码，需要在执行完手动解锁！

代码示例

package Thread08;

import java.util.concurrent.locks.ReentrantLock;

public class Thread08 {
    public static void main(String[] args) {
        MyThread mm = new MyThread();

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


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


class MyThread implements Runnable {
    private int s = 100;

    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {

            try {
                lock.lock(); //调用 锁定方法 lock()
                if(s>0) {
                    try {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + ':' + s);
                        s--;
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }finally {
                lock.unlock(); // 调用解锁方法
            }
        }
    }
}

线程同步出现死锁问题

什么叫死锁?
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
出现死锁后，不会出现异常，不会出现提示，知识所有的线程都处于阻塞状态，无法继续
如何解决死锁问题？
尽量减少同步资源的定义
尽量避免嵌套同步

线程通信问题

使用线程通信完成两个线程之间交替

通过调用 wait()方法 与 notify()或者notifyall()

函数解释：
wait(): 一旦执行此方法， 当前线程就会进入阻塞状态，并释放同步监视器
notify(): 一旦执行此方法， 就会唤醒wait的一个线程， 如果多个线程被wait，就唤醒优先级高的。
notifyall(): 一旦执行此方法，就会唤醒所有被wait的线程。

说明：
这三个方法必须使用在同步代码块，或者同步方法中。
这三个的调用者必须是同步方法或者同步代码块中的同步监视器。 否则会出现IllegalMonitorStateException异常
这三个方法都是定义在java.lang.Object类中。

代码：

package jzq.com.Thread10;

public class Thread10 {
    public static void main(String[] args) {
        MyThread mm = new MyThread();

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


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

    }
}


class MyThread implements Runnable {

    private int s = 0;
    private Object obj = new Object();

    @Override
    public void run() {

        while (true) {
            synchronized (obj) {

                obj.notify();

                if(s<100) {
                    try {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + ":" + s);
                        s++;
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }

                try {
                    obj.wait();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
java基础多线程练习题（1）
08-08
java基础之多线程的练习题，博客访问地址： http://blog.youkuaiyun.com/u014028392/article/details/76906801
Java多线程练习
暴力扬
11-26 507
文章目录练习一要求题解第一问第二问 练习一 要求 定义继承 Thread 的类 改写类的 run 方法，要求每 150 毫秒打印一次线程名 在 main 中 3 次实例化这个类，并调用,同时注意显示的结果 定义实现 Runnable 接口的类 此类的 run 方法，要求每 50 毫秒打印一次线程名 在 main 中 3 次实例化这个类，并调用 在 main 中使用匿名类方式实现 Runnable 接口的类，要求每 120 毫秒打印一次线程名 然后在执行另一个匿名类，要求每 100 毫秒, 打印一个随机整数
Java多线程编程实战：10个经典练习题详解与代码实现
最新发布
04-06 636
在多线程环境中，多个线程可能会同时访问和修改共享资源，导致数据竞争和不一致的问题。在多线程编程中，线程是程序执行的基本单位之一。修饰时，线程对变量的修改会立即写入主内存，其他线程可以立即看到变量的最新值。是Java中用于管理线程池的接口。通过线程池可以复用线程，提高线程的利用率。块用于同步代码块，确保多个线程访问共享资源时的线程安全。方法实现，而线程的停止可以通过设置一个标志变量来实现。方法用于暂停当前线程的执行，指定的时间内线程不会运行。接口，可以将线程的逻辑封装到一个对象中，然后通过。
Java 多线程练习
qq_57570052的博客
07-28 2863
1.定时器操作（实现电脑定时关机）。2.每个月的月末(02:00:00)执行一次代码3.模拟售票模拟了多个线程同时售票的场景，保证了并发环境下的票的售卖过程的正确性和一致性。4.用15个线程实现，求123456789之间放+-和为100的表达式（11结果），如果一个线程求出结果， 立即告诉其它停止。
Java多线程练习题
11-21
这是对Java多线程的一些相关练习题 包括选择 填空 简答 编程等题型
Java多线程练习源代码
01-11
本资源“Java多线程练习源代码”提供了一系列的示例，旨在帮助开发者深入理解和熟练掌握Java多线程的运用。 1. **线程的概念与创建** 线程是程序执行的最小单元，一个进程可以有多个线程同时执行任务。在Java中，...
java多线程练习demo 基本的线程使用方式 生产者消费者练习 龟兔赛跑练习.zip
11-01
"java多线程练习demo" 提供了一系列实例，帮助开发者理解和掌握如何在Java中创建和管理线程。在这个压缩包中，我们可以找到一个名为 "multithreading-master" 的文件夹，它可能包含了多个关于多线程的示例项目，比如...
多线程demo/java多线程练习
05-17
本项目"多线程demo/java多线程练习"旨在通过实际操作来深入理解和掌握多线程技术，同时模拟数据库操作，这在现代应用程序开发中至关重要。 1. **线程基础** - **创建线程**：Java提供了两种创建线程的方式，分别是...
JAVA多线程练习题答案。
04-13
JAVA多线程练习题答案详解 在本文中，我们将对 JAVA 多线程练习题的答案进行详细的解释和分析。这些题目涵盖了 JAVA 多线程编程的基本概念和技术，包括线程的生命周期、线程同步、线程状态、线程优先级、线程安全等...
JAVA多线程练习题。
04-12
JAVA多线程练习题。都是一些基本的练习题。对初学者有帮助
java 多线程 练习
qq_29087535的博客
02-12 489
Runnable.java(实现Runnable接口) package com.jhy.www.thread; //通过实现 Runnable 接口来创建线程 public class RunnableDemo implements Runnable { private Thread t; private String threadName; public Runnab...
【JavaSE】多线程篇（五）线程专项练习题
黄小黄的博客
09-07 1005
本文整理了一些多线程的练习题，包括取钱问题、通知终止线程的编程练习，判断与简答，供读者学习练习使用。
java多线程练习
ThinkPet
02-19 517
package demoThread; import java.util.Scanner; public class TestThread { public static void main(String[] args) { Scanner sc=new Scanner(System.in); System.out.println("请输入循环上限:"); int a=sc.n...
java多线程练习题
xwt1130_的博客
11-13 1185
java多线程练习题
java之多线程综合练习
qq_63431773的博客
11-26 541
需求：一共有1000张电影票,可以在两个窗口领取,假设每次领取的时间为3000毫秒,请用多线程模拟卖票过程并打印剩余电影票的数量。
Java多线程练习与数据库模拟操作
资源摘要信息: "多线程demo与Java多线程练习" 在Java编程语言中，多线程是一项核心的并发编程技术，它允许程序同时执行多个线程来提高应用程序的效率和响应速度。本资源提供了一个多线程的实践示例，特别是一个名为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值