java多线程

最新推荐文章于 2024-11-04 20:33:37 发布

小张小张遇事不慌832

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量933

点赞数 11

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_73778697/article/details/141258864

版权

Java 多线程是指在一个程序中同时执行多个线程。线程是操作系统能够进行运算调度的最小单位，它是进程中的一个执行路径。Java 提供了内建的多线程支持，使得程序可以并行处理任务，从而提高效率。以下是一些关键点：

线程创建：Java 中可以通过继承 Thread 类或实现 Runnable 接口来创建线程。继承 Thread 类时，需要重写 run() 方法；实现 Runnable 接口时，需要实现 run() 方法，并将其作为参数传递给 Thread 类。
继承 Thread 类：

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}
MyThread thread = new MyThread();
thread.start();  // 启动线程

实现 Runnable 接口：

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable is running");
    }
}
Thread thread = new Thread(new MyRunnable());
thread.start();  // 启动线程

线程管理：可以使用 Thread 类中的方法来管理线程，如 start() 启动线程，sleep() 使线程暂停，join() 等待线程完成，interrupt() 中断线程等。

线程同步：为了避免多个线程同时访问共享资源时出现数据不一致的问题，Java 提供了同步机制。使用 synchronized 关键字可以在方法或代码块上实现同步，确保同一时刻只有一个线程可以执行被同步的代码。
使用 synchronized：

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

使用 ReentrantLock：

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

线程池：Java 提供了 java.util.concurrent 包中的线程池类，如 ExecutorService，可以更有效地管理和复用线程，避免频繁创建和销毁线程。
线程安全：除了使用同步机制，Java 还提供了线程安全的集合类（如 ConcurrentHashMap）和原子类（如 AtomicInteger），可以在多线程环境中安全地操作共享数据。

还有一个可能在开发过程中遇到的小问题，有关于锁的问题

观察下面两份代码

package com.cn1;

class TicketsThread3 implements Runnable {
    private static int tickets = 10; // 共享的票数
    private static final Object lock = new Object(); // 锁对象

    @Override
    public void run() {
        while (true) {
            synchronized (lock) { // 确保对票务的访问是线程安全的
                if (tickets > 0) {
                    Thread thread = Thread.currentThread();
                    String name = thread.getName();
                    System.out.println(name + " 正在发售第 " + tickets-- + " 张票");
                } else {
                    break; // 票卖完后退出循环
                }
            }
            // 可以选择在每次发售票后让线程休息一小会，以便观察输出
            try {
                Thread.sleep(100); // 休眠100毫秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重置中断状态
            }
        }
    }
}

public class Demo6 {
    public static void main(String[] args) {
        TicketsThread3 ticketsThread3 = new TicketsThread3();
        Thread window1 = new Thread(ticketsThread3, "窗口1");
        Thread window2 = new Thread(ticketsThread3, "窗口2");
        Thread window3 = new Thread(ticketsThread3, "窗口3");
        Thread window4 = new Thread(ticketsThread3, "窗口4");

        window1.start();
        window2.start();
        window3.start();
        window4.start();
    }
}

运行结果：

第二份代码：

package com.cn2;

class TicketWin implements Runnable {
    private static int ticket = 10;
    private static final Object lock = new Object(); // 锁对象

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {//锁机制，synchronized（参数）表示同步，参数表示同步锁
                if (ticket > 0) {
                    Thread thread = Thread.currentThread();
                    String name = thread.getName();
                    System.out.println(name + " 卖出的票 " + ticket--);
                } else {
                    break;
                }

                // 可以选择在每次发售票后让线程休息一小会，以便观察输出
                try {
                    Thread.sleep(100); // 休眠100毫秒
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 重置中断状态
                }
            }
        }
    }
}
public class Demo5 {
    public static void main(String[] args) {
        TicketWin t1 = new TicketWin();
        Thread thread1= new Thread(t1,"窗口1");
        Thread thread2= new Thread(t1,"窗口2");
        Thread thread3= new Thread(t1,"窗口3");
        Thread thread4= new Thread(t1,"窗口4");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

    }
}

运行结果