如何理解java的多线程？

于 2024-05-28 14:22:53 发布
阅读量620 收藏 9
点赞数 6
分类专栏： Java面试题 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33326733/article/details/139265882
版权

随着计算机硬件的发展和互联网应用的普及，多线程编程在现代软件开发中变得尤为重要。然而，尽管多线程编程能够显著提高程序的执行效率和并发能力，它也带来了许多潜在的问题和挑战。

为什么要使用多线程?

从计算机底层来说

线程是轻量级的进程：
线程是程序执行的最小单位。相比进程，线程的切换和调度成本要低得多。进程之间的切换涉及到完整的上下文切换，包括内存空间、文件句柄等，而线程共享进程的这些资源，因此只需要切换少量的上下文信息。

多核CPU时代：
现代计算机通常具备多核CPU，这意味着多个线程可以同时在不同的核上运行，从而充分利用硬件资源，减少线程上下文切换的开销。

java

public class MultiThreadExample {
    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " is running");
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

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

在上述代码中，我们创建了两个线程，它们会在多核CPU上并行执行，从而提高程序的执行效率。

从当代互联网发展趋势来说

现代互联网应用动辄需要面对百万级甚至千万级的并发量。多线程编程是开发高并发系统的基础，通过多线程机制可以大大提高系统的并发能力和性能。

java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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

        for (int i = 0; i < 100; i++) {
            executorService.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " is processing request");
            });
        }

        executorService.shutdown();
    }
}

上面的代码展示了如何使用线程池来处理高并发请求。通过Executors.newFixedThreadPool创建一个固定大小的线程池，可以有效管理并发线程的数量，从而避免系统资源被过多的线程消耗。

单核时代 vs 多核时代

单核时代：
在单核时代，多线程主要是为了提高单进程利用CPU和IO系统的效率。假设一个Java进程只有一个线程，当线程请求IO时会被阻塞，导致整个进程被阻塞。通过多线程，一个线程被IO阻塞时，其他线程可以继续使用CPU，从而提高系统资源的整体利用效率。

java

public class SingleCoreExample {
    public static void main(String[] args) {
        Thread ioThread = new Thread(() -> {
            try {
                Thread.sleep(3000); // Simulate IO operation
                System.out.println("IO operation completed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread cpuThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("CPU operation " + i);
            }
        });

        ioThread.start();
        cpuThread.start();
    }
}

在上述代码中，一个线程进行IO操作，另一个线程进行CPU操作，从而避免了进程的完全阻塞。

多核时代：
在多核时代，多线程可以提高进程利用多核CPU的能力。假如我们要计算一个复杂任务，如果只使用一个线程，那么不论系统有多少CPU核心，都只会有一个核心被利用到。但如果创建多个线程，这些线程可以被调度到不同的CPU核心上并行执行，从而显著提升任务的执行效率。

java

public class MultiCoreExample {
    public static void main(String[] args) {
        int numberOfThreads = Runtime.getRuntime().availableProcessors();
        
        ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads);
        
        for (int i = 0; i < numberOfThreads; i++) {
            executorService.execute(() -> {
                for (int j = 0; j < 5; j++) {
                    System.out.println(Thread.currentThread().getName() + " is performing task " + j);
                }
            });
        }

        executorService.shutdown();
    }
}

在上述代码中，我们根据可用CPU核心数创建了一个固定大小的线程池，让每个核心都能被充分利用，从而提高计算任务的执行效率。

使用多线程可能带来什么问题?

尽管多线程编程能够显著提高程序的执行效率，但它也带来了许多潜在的问题和挑战。以下是多线程编程可能带来的主要问题及其解决方案。

1. 内存泄漏

多线程编程可能导致内存泄漏，特别是在线程池的使用过程中。如果线程池中的线程没有被正确地回收，或者线程持有对对象的引用而没有及时释放，这些对象将无法被垃圾回收器回收，从而导致内存泄漏。

示例：

java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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

        while (true) {
            executorService.execute(() -> {
                // Simulate task
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

在上述代码中，由于不断创建新的任务，线程池中的线程可能会持有大量对象的引用，导致内存无法被及时回收，最终引发内存泄漏。

解决方案：

确保线程池能够正确地终止，并且在线程池中执行的任务不应持有对对象的长时间引用。

java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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

        for (int i = 0; i < 100; i++) {
            executorService.execute(() -> {
                // Simulate task
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executorService.shutdown();
    }
}

2. 死锁

死锁是多线程编程中最常见且难以调试的问题之一。当两个或多个线程相互等待对方持有的资源时，就会发生死锁，导致线程永久阻塞。

示例：

java

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");

                try { Thread.sleep(10); } catch (InterruptedException e) {}

                System.out.println("Thread 1: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread 1: Holding lock 1 & 2...");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2...");

                try { Thread.sleep(10); } catch (InterruptedException e) {}

                System.out.println("Thread 2: Waiting for lock 1...");
                synchronized (lock1) {
                    System.out.println("Thread 2: Holding lock 1 & 2...");
                }
            }
        });

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

在上述代码中，Thread 1持有lock1并等待lock2，同时Thread 2持有lock2并等待lock1，导致死锁。

解决方案：

避免嵌套锁定，尽量使用锁的顺序一致性，或者使用更高级的并发工具例如java.util.concurrent包中的锁。

java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockSolution {
    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                lock1.lock();
                System.out.println("Thread 1: Holding lock 1...");
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                lock2.lock();
                System.out.println("Thread 1: Holding lock 1 & 2...");
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                lock1.lock();
                System.out.println("Thread 2: Holding lock 1...");
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                lock2.lock();
                System.out.println("Thread 2: Holding lock 1 & 2...");
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

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

3. 线程不安全

线程不安全是指多个线程同时访问和修改共享资源时，可能导致数据的不一致性。

示例：

java

public class ThreadUnsafeExample {
    private static int counter = 0;

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter++;
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

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

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counter);
    }
}

在上述代码中，两个线程同时修改counter变量，可能导致最终的计数值不正确。

解决方案：

使用同步机制，例如sychronized关键字，或者使用java.util.concurrent包中的并发工具。

java

public class ThreadSafeExample {
    private static int counter = 0;

    public static synchronized void increment() {
        counter++;
    }

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

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

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counter);
    }
}

总结

尽管多线程编程能够显著提高程序的执行效率，但同时也带来了许多潜在的问题，如内存泄漏、死锁和线程不安全等。通过合理的设计和使用Java提供的并发工具，可以有效地避免这些问题，提高程序的稳定性和可靠性。

qq_33326733
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值