string builder和buffer

于 2024-12-15 20:36:22 发布
阅读量969 收藏 8
点赞数 11
文章标签： java 面试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_52122048/article/details/144490035
版权

String、StringBuffer和StringBuilder的区别（面试题）_android 开发 string stringbuffer stringbuilder面试题-优快云博客

join方法 

 // 调用 join() 的线程会被阻塞，直到目标线程（如 t1）执行完成（即线程终止）。
        //一旦目标线程结束，阻塞会解除，当前线程恢复执行。

//        执行流程：
//
//        主线程依次调用 t1.join()，t2.join()，t3.join()。
//        主线程会先等待 t1 完成，然后等待 t2，最后等待 t3。
//        只有当所有线程都执行完毕后，主线程（main）才能继续执行后续代码。

演示实例:

public class StringBufferExample {
    // 使用 StringBuffer 来保存线程安全的字符串
    private static final StringBuffer sharedBuffer = new StringBuffer();

    public static void main(String[] args) {
        // 创建多个线程对 sharedBuffer 进行操作
        Thread t1 = new Thread(new StringAppender("Thread1-"));
        Thread t2 = new Thread(new StringAppender("Thread2-"));
        Thread t3 = new Thread(new StringAppender("Thread3-"));

        // 启动线程
        t1.start();
        t2.start();
        t3.start();

        // 等待线程执行完成
        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出最终结果
        System.out.println("Final Result: " + sharedBuffer.toString());
    }

    // 定义线程任务：向 sharedBuffer 中追加字符串
    static class StringAppender implements Runnable {
        private final String text;

        public StringAppender(String text) {
            this.text = text;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                // 同步操作，由 StringBuffer 内部负责
                sharedBuffer.append(text).append(i).append(" ");
                try {
                    Thread.sleep(50); // 模拟操作耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出因为线程问题导致数据每次结果不一致:示例其中一个输出:

Thread1-0 Thread1-1 Thread1-2 Thread1-3 Thread1-4 Thread2-0 Thread2-1 Thread2-2 Thread2-3 Thread2-4 Thread3-0 Thread3-1 Thread3-2 Thread3-3 Thread3-4 

  • StringBuffer 确保线程安全，但线程安全并不等于输出顺序固定。
  • 如果需要输出结果的顺序一致，需要控制线程执行的顺序，比如通过 join 顺序或显式同步控制。
  • 如果线程顺序无关紧要，则可以直接使用当前代码，线程安全不会导致数据问题。

join() 只保证“完成顺序”，而非“启动顺序”：

线程安全与不安全演示: 

/**
 * 功能：
 * 作者：IT伟
 * 日期：2024/12/15 19:16
 */
public class ThreadSafetyExample {
    // 使用 StringBuffer（线程安全）
    private static final StringBuffer safeBuffer = new StringBuffer();
    // 使用 StringBuilder（非线程安全）
    private static final StringBuilder unsafeBuilder = new StringBuilder();

    public static void main(String[] args) throws InterruptedException {
        // 演示 StringBuffer 的线程安全
        Thread t1 = new Thread(() -> appendSafeBuffer("Thread1-"));
        Thread t2 = new Thread(() -> appendSafeBuffer("Thread2-"));
        Thread t3 = new Thread(() -> appendSafeBuffer("Thread3-"));

        // 演示 StringBuilder 的非线程安全
        Thread t4 = new Thread(() -> appendUnsafeBuilder("Thread4-"));
        Thread t5 = new Thread(() -> appendUnsafeBuilder("Thread5-"));
        Thread t6 = new Thread(() -> appendUnsafeBuilder("Thread6-"));

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();

        // 等待线程完成
        t1.join();
        t2.join();
        t3.join();
        t4.join();
        t5.join();
        t6.join();

        // 打印结果
        System.out.println("StringBuffer (Safe): " + safeBuffer.toString());
        System.out.println("StringBuilder (Unsafe): " + unsafeBuilder.toString());
    }

    // 使用线程安全的 StringBuffer
    private static void appendSafeBuffer(String text) {
        for (int i = 1; i <= 5; i++) {
            safeBuffer.append(text).append(i).append(" ");
            try {
                Thread.sleep(50); // 模拟操作耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 使用非线程安全的 StringBuilder
    private static void appendUnsafeBuilder(String text) {
        for (int i = 1; i <= 5; i++) {
            unsafeBuilder.append(text).append(i).append(" ");
            try {
                Thread.sleep(50); // 模拟操作耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

这样才能演示线程安全和不安全:通过对比**线程安全的类（如 StringBuffer）和非线程安全的类（如 StringBuilder）**在多线程环境下的行为来说明线程安全的重要性。

运行三次，可以看到

线程安全的 StringBuffer：

  • 输出始终完整且正确，线程间没有数据覆盖或丢失。(虽然执行顺序还是混乱的)

非线程安全的 StringBuilder：

  • 输出会出现数据混乱、覆盖或丢失。

安全与不安全原因:

  • StringBuffer 的线程安全：

    • 它的所有方法（如 append）都加了 synchronized 修饰，确保同一时间只有一个线程可以访问它的方法。

    • 线程间对 StringBuffer 的操作被串行化，避免了数据冲突。

  • StringBuilder 的非线程安全：

    • 它的操作没有 synchronized 修饰，同一时间多个线程可以同时操作，导致竞态条件（Race Condition）。

    • 结果是某个线程的操作可能覆盖或打乱另一个线程的操作。

如何演示线程安全问题的出现

如果想让问题更加明显，可以增加以下方式：

  1. 加速线程冲突：

    • 减少 Thread.sleep 的时间（如改为 10ms）。
    • 增加线程的数量（如启动 10 个线程）。

  2. 增加非线程安全部分的数据竞争：

    在 appendUnsafeBuilder 方法中增加更复杂的字符串操作，比如同时调用 insert 或 delete 方法。

 修改:让budilder也安全:可以避免数据冲突，但性能会有所降低。

// 使用非线程安全的 StringBuilder
private static void appendUnsafeBuilder(String text) {
    synchronized (unsafeBuilder) {
        for (int i = 1; i <= 5; i++) {
            unsafeBuilder.append(text).append(i).append(" ");
            try {
                Thread.sleep(50); // 模拟操作耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

拓展:

让线程按顺序执行:同步就是这个意思

使用join:而且是这样子，不能一起启动再一起join(as上面一样，直接并行执行了)
t1.start();
t1.join();

t2.start();
t2.join();

t3.start();
t3.join();
使用信号量/同步块: 这样可以一起start再一起join都没事

有多个线程并发执行，并且你想控制它们按顺序执行，可以使用 synchronized 或其他同步机制，结合一个共享的标志变量来控制线程的执行顺序。

/**
 * 功能：
 * 作者：IT伟
 * 日期：2024/12/15 19:47
 */
public class ThreadOrderExample {
    private static final Object lock = new Object();
    private static int currentThread = 1;  // 用来控制线程的顺序

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> printOrder(1, "Thread 1"));
        Thread t2 = new Thread(() -> printOrder(2, "Thread 2"));
        Thread t3 = new Thread(() -> printOrder(3, "Thread 3"));

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

        t1.join();
        t2.join();
        t3.join();

        System.out.println("All threads finished.");
    }

    private static void printOrder(int threadNumber, String threadName) {
        synchronized (lock) {
            while (currentThread != threadNumber) {
                try {
                    lock.wait(); // 等待，直到轮到该线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(threadName + " is running");
            currentThread++;  // 更新到下一个线程
            lock.notifyAll(); // 通知其他线程可以继续
        }
    }
}

private static final Object lock = new Object(); 主要用于线程同步，确保在多线程环境中只有一个线程能够执行临界区代码（即修改共享资源的部分）。这个对象 lock 充当了一个锁，通过它可以控制对共享资源的访问。

创建了一个名为 lock 的对象，它是一个共享的锁对象。多个线程可以通过这个对象来进行同步。

接下来，在需要确保线程按顺序执行的代码块中，我们会使用 synchronized(lock) 来保证每次只有一个线程可以进入到这个代码块中执行。（只能保证线程与线程之间不干扰，但是没法保证他们执行顺序，所以外加一个lock对象来控制,结合wait notify）

锁对象 lock 的作用：

  1. 线程同步：

    • synchronized (lock) 保证了同一时刻，只有一个线程能够执行 printOrder 方法中的代码。其他线程会被阻塞，直到持有 lock 锁的线程执行完并释放锁。

  2. 控制线程顺序：

    • while (currentThread != threadNumber) 这部分逻辑检查是否当前是当前线程应该执行的时机，如果不是，则调用 lock.wait() 让线程进入等待状态，直到 currentThread 的值匹配当前线程编号。
    • 这样，线程会在它们应该执行的时机才能继续执行，从而保证了线程的顺序性。

  3. notifyAll() 唤醒所有线程：

    • 当一个线程执行完后，它调用 lock.notifyAll()，通知其他等待的线程继续执行。这时，其他线程会重新检查条件（currentThread == threadNumber），直到它们的时机到来。
使用 CountDownLatch 控制线程顺序：这样可以一起start再一起join都没事

CountDownLatch 是一个线程同步工具类，可以让一个或多个线程等待直到其他线程完成某些操作。我们可以通过它来确保线程按顺序执行。

import java.util.concurrent.CountDownLatch;

public class ThreadOrderWithLatch {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch1 = new CountDownLatch(1);  // 控制 t2 在 t1 之后执行
        CountDownLatch latch2 = new CountDownLatch(1);  // 控制 t3 在 t2 之后执行

        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
            latch1.countDown();  // t1 完成，释放 t2
        });

        Thread t2 = new Thread(() -> {
            try { latch1.await(); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("Thread 2 is running");
            try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
            latch2.countDown();  // t2 完成，释放 t3
        });

        Thread t3 = new Thread(() -> {
            try { latch2.await(); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("Thread 3 is running");
        });

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

        t1.join();
        t2.join();
        t3.join();

        System.out.println("All threads finished.");
    }
}
使用 CyclicBarrier 控制线程顺序

CyclicBarrier 类允许一组线程互相等待，直到所有线程都到达某个公共屏障点。它适用于所有线程必须同时到达某个同步点的场景。

import java.util.concurrent.CyclicBarrier;

public class ThreadOrderWithBarrier {
    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier barrier1 = new CyclicBarrier(1);  // 让 t2 等待 t1 完成
        CyclicBarrier barrier2 = new CyclicBarrier(1);  // 让 t3 等待 t2 完成

        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
            try { barrier1.await(); } catch (Exception e) { e.printStackTrace(); }
        });

        Thread t2 = new Thread(() -> {
            try { barrier1.await(); } catch (Exception e) { e.printStackTrace(); }
            System.out.println("Thread 2 is running");
            try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
            try { barrier2.await(); } catch (Exception e) { e.printStackTrace(); }
        });

        Thread t3 = new Thread(() -> {
            try { barrier2.await(); } catch (Exception e) { e.printStackTrace(); }
            System.out.println("Thread 3 is running");
        });

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

        t1.join();
        t2.join();
        t3.join();

        System.out.println("All threads finished.");
    }
}

总结

  • join() 方法最简单，通过让线程依次等待执行，保证顺序执行。
  • synchronized 和 wait/notify 提供更细粒度的控制，可以在多线程之间控制执行顺序。
  • CountDownLatch 和 CyclicBarrier 提供了基于计数的同步机制，适合更复杂的线程调度需求。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值