java多线程使用教程

简介: java多线程使用教程

如何使用多线程


在Java中,创建多线程的方式有两种:一种是继承Thread类,另一种是实现Runnable接口。以下是两种方式的详细介绍和代码示例:


继承Thread类


创建一个多线程,可以继承Thread类并重写它的run()方法。run()方法是线程的主体,当线程启动后,它的run()方法会被调用,并且该方法的执行过程中,线程将处于“运行”状态。


下面是一个简单的继承Thread类的多线程示例:

public class MyThread extends Thread {
    public void run() {
        // 线程的主体,可以在这里编写需要执行的代码
    }
}


使用这个类创建一个新线程非常简单,只需要实例化该类并调用它的start()方法即可。start()方法会启动线程并调用run()方法。

MyThread myThread = new MyThread();
myThread.start();


实现Runnable接口


Java中还提供了一种创建多线程的方式,即实现Runnable接口。实现Runnable接口的类需要实现run()方法,该方法的代码将被线程执行。


下面是一个实现Runnable接口的多线程示例:

public class MyRunnable implements Runnable {
    public void run() {
        // 线程的主体,可以在这里编写需要执行的代码
    }
}


使用这个类创建一个新线程的方式和继承Thread类的方式类似,只需要实例化该类并将它作为参数传递给Thread的构造方法即可。

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();


线程的生命周期


线程的生命周期指的是线程从创建到销毁的整个过程。Java线程的生命周期可以分为以下5个阶段:


新建状态(New):当一个线程被创建时,它处于新建状态。此时线程还没有开始执行,也还没有分配到系统资源。


就绪状态(Runnable):当线程调用start()方法后,线程处于就绪状态。此时线程已经分配到了系统资源,等待系统调度它的时候开始执行。


运行状态(Running):当线程被系统调度执行时,线程处于运行状态。此时线程正在执行run()方法中的代码。


阻塞状态(Blocked):线程在执行过程中,可能会因为某些原因需要暂停执行,此时线程处于阻塞状态。比如,线程被sleep()、wait()、join()等方法调用时,线程将进入阻塞状态。


终止状态(Terminated):线程执行完了run()方法中的代码,或者因为异常而中断了线程,此时线程将进入终止状态。终止状态的线程不再执行任何代码。


下面是一个简单的演示线程生命周期的示例:

public class MyThread extends Thread {
    public void run() {
        System.out.println("线程处于新建状态");
        try {
            Thread.sleep(1000);
            System.out.println("线程处于就绪状态");
            Thread.sleep(1000);
            System.out.println("线程处于运行状态");
            Thread.sleep(1000);
            System.out.println("线程处于阻塞状态");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


在这个示例中,线程将会依次进入新建状态、就绪状态、运行状态和阻塞状态。运行这个线程的代码如下:

MyThread myThread = new MyThread();
myThread.start();



线程同步


在多线程程序中,由于多个线程共享同一份资源,可能会发生冲突问题,比如多个线程同时对同一变量进行写操作,这时就需要使用同步机制来保证线程安全。


Java提供了两种同步机制:synchronized关键字和Lock接口。synchronized关键字是Java中最常用的同步机制,它可以用来修饰方法或代码块。当一个方法或代码块被synchronized修饰后,只有一个线程能够执行该方法或代码块。


下面是一个使用synchronized关键字实现线程同步的示例:

public class MyThread implements Runnable {
    private int count = 0;
    public synchronized void increase() {
        count++;
    }
    public void run() {
        for (int i = 0; i < 100000; i++) {
            increase();
        }
    }
}


在这个示例中,increase()方法被synchronized关键字修饰,当一个线程执行increase()方法时,其他线程必须等待,直到当前线程执行完毕才能执行该方法。


下面是一个使用Lock接口实现线程同步的示例:

public class MyThread implements Runnable {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    public void increase() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    public void run() {
        for (int i = 0; i < 100000; i++) {
            increase();
        }
    }
}


在这个示例中,increase()方法使用了Lock接口来实现线程同步,当一个线程获取了锁后,其他线程必须等待,直到当前线程释放锁才能获取锁执行该方法。


线程间通信


多个线程之间需要进行通信时,可以使用wait()、notify()和notifyAll()方法来实现。


wait()方法会使当前线程进入等待状态,直到其他线程调用notify()或notifyAll()方法唤醒该线程。notify()方法会随机唤醒一个处于等待状态的线程,而notifyAll()方法会唤醒所有处于等待状态的线程。


下面是一个使用wait()和notify()方法实现线程间通信的示例:

public class MyThread implements Runnable {
    private boolean ready = false;
    public synchronized void waitForReady() throws InterruptedException {
        while (!ready) {
            wait();
        }
    }
    public synchronized void setReady() {
        ready = true;
        notify();
    }
    public void run() {
        try {
            waitForReady();
            System.out.println("Thread is ready.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


在这个示例中,waitForReady()方法会使当前线程进入等待状态,直到其他线程调用setReady()方法将ready标志设置为true并调用notify()方法唤醒该线程。

运行这个线程的代码如下:

MyThread myThread = new MyThread();
new Thread(myThread).start();
Thread.sleep(1000);
myThread.setReady();

在这个代码中,启动了一个线程并休眠1秒钟,然后调用setReady()方法将ready标志设置为true并调用notify()方法唤醒该线程。


线程池

线程池是一种重用线程的机制,它可以避免线程的频繁创建和销毁,提高了线程的利用率和效率。


Java提供了Executor框架来实现线程池。Executor框架提供了一些接口,如Executor、ExecutorService、ScheduledExecutorService等,可以用来创建线程池。


下面是一个使用Executor框架实现线程池的示例:

public class MyThread implements Runnable {
    private int taskId;
    public MyThread(int taskId) {
        this.taskId = taskId;
    }
    public void run() {
        System.out.println("Task " + taskId + " is running.");
        }
public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(3);
    for (int i = 1; i <= 10; i++) {
        executorService.submit(new MyThread(i));
    }
    executorService.shutdown();
}
}


在这个示例中,创建了一个包含3个线程的线程池,然后提交了10个任务给线程池执行。最后调用shutdown()方法关闭线程池。


相关文章
|
9天前
|
安全 Java
Java之泛型使用教程
Java之泛型使用教程
111 10
|
21天前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
Java 数据库 Spring
59 0
|
1月前
|
算法 Java
Java多线程编程:实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
90 16
|
2月前
|
缓存 并行计算 安全
关于Java多线程详解
本文深入讲解Java多线程编程,涵盖基础概念、线程创建与管理、同步机制、并发工具类、线程池、线程安全集合、实战案例及常见问题解决方案,助你掌握高性能并发编程技巧,应对多线程开发中的挑战。
|
2月前
|
Java 关系型数据库 数据库
Java 项目实战教程从基础到进阶实战案例分析详解
本文介绍了多个Java项目实战案例,涵盖企业级管理系统、电商平台、在线书店及新手小项目,结合Spring Boot、Spring Cloud、MyBatis等主流技术,通过实际应用场景帮助开发者掌握Java项目开发的核心技能,适合从基础到进阶的学习与实践。
230 3
|
2月前
|
数据采集 存储 前端开发
Java爬虫性能优化:多线程抓取JSP动态数据实践
Java爬虫性能优化:多线程抓取JSP动态数据实践
|
3月前
|
缓存 安全 Java
Java 并发新特性实战教程之核心特性详解与项目实战
本教程深入解析Java 8至Java 19并发编程新特性,涵盖CompletableFuture异步编程、StampedLock读写锁、Flow API响应式流、VarHandle内存访问及结构化并发等核心技术。结合电商订单处理、缓存系统、实时数据流、高性能计数器与用户资料聚合等实战案例,帮助开发者高效构建高并发、低延迟、易维护的Java应用。适合中高级Java开发者提升并发编程能力。
75 0
|
3月前
|
Java API 调度
从阻塞到畅通:Java虚拟线程开启并发新纪元
从阻塞到畅通:Java虚拟线程开启并发新纪元
309 83
|
3月前
|
安全 算法 Java
Java 多线程:线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术,涵盖线程的创建与启动、线程安全问题及其解决方案,包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法,帮助开发者提升程序性能与稳定性。
145 0