java实现线程阻塞式方法_Java

在java编程中，阻塞式方法（blocking methods）指的是那些在被调用后，当前线程会暂停执行，直到某些条件满足或事件发生后才继续运行的方法。在这种情况下，当前线程会进入阻塞状态（blocking state），并且不会占用cpu资源，但也无法执行任何其他操作，直到该方法完成或条件满足。

1. 阻塞式方法的特点

阻塞式方法通常有以下几个特点：

暂停线程执行：调用阻塞式方法的线程会被挂起，进入阻塞状态，直到方法返回或条件满足为止。
不占用cpu资源：阻塞状态下的线程不会消耗cpu时间片，因此不会对系统性能造成直接负担，但它会阻止线程执行其他任务。
依赖外部条件：阻塞式方法通常等待某种外部条件或事件，例如i/o操作完成、锁释放、线程被唤醒等。
潜在的影响：如果没有妥善处理，阻塞式方法可能导致线程长时间处于等待状态，进而影响应用程序的响应能力和并发性能。

2. java中的常见阻塞式方法

在java中，有许多常见的阻塞式方法，它们通常出现在多线程编程、i/o操作和网络编程中。

2.1 thread.sleep()

thread.sleep(long millis) 是一个阻塞式方法，用于使当前线程休眠指定的毫秒数。在此期间，线程处于阻塞状态，不会执行任何操作，直到指定的时间过去。

public class sleepexample {
    public static void main(string[] args) {
        system.out.println("thread is going to sleep...");
        try {
            thread.sleep(2000);  // 线程休眠2秒
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("thread woke up!");
    }
}

在这个例子中，thread.sleep(2000) 使当前线程阻塞2秒，之后继续执行。

2.2 object.wait()

object.wait() 是一个阻塞式方法，它使当前线程进入等待状态，直到其他线程调用 notify() 或 notifyall() 方法唤醒它。通常用于线程间的同步和通信。

public class waitnotifyexample {
    private static final object lock = new object();

    public static void main(string[] args) {
        thread waitingthread = new thread(() -> {
            synchronized (lock) {
                try {
                    system.out.println("thread is waiting...");
                    lock.wait();  // 线程进入等待状态
                    system.out.println("thread is resumed!");
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        });

        thread notifyingthread = new thread(() -> {
            synchronized (lock) {
                system.out.println("thread is notifying...");
                lock.notify();  // 唤醒等待的线程
            }
        });

        waitingthread.start();
        try {
            thread.sleep(1000);  // 确保waitingthread进入等待状态
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        notifyingthread.start();
    }
}

在这个例子中，wait() 方法使 waitingthread 进入等待状态，直到 notifyingthread 调用 notify() 方法将其唤醒。

2.3 thread.join()

thread.join() 是一个阻塞式方法，它让当前线程等待另一个线程完成执行后再继续。例如，如果在主线程中调用 t.join()，主线程将被阻塞，直到线程 t 运行完毕。

public class joinexample {
    public static void main(string[] args) {
        thread t = new thread(() -> {
            try {
                thread.sleep(2000);
                system.out.println("thread finished execution");
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
        });

        t.start();

        try {
            t.join();  // 主线程等待t线程完成
        } catch (interruptedexception e) {
            e.printstacktrace();
        }

        system.out.println("main thread continues after t finishes");
    }
}

在这个例子中，t.join() 使主线程阻塞，直到 t 线程执行完毕。

2.4 i/o 操作中的阻塞方法

在java中，i/o操作（如文件读写、网络通信）通常是阻塞式的。例如，inputstream.read() 方法在没有数据可供读取时会使当前线程阻塞，直到数据可用或达到流的末尾。

import java.io.fileinputstream;
import java.io.ioexception;

public class filereadexample {
    public static void main(string[] args) {
        try (fileinputstream fis = new fileinputstream("example.txt")) {
            int data;
            while ((data = fis.read()) != -1) {  // read() 是阻塞式方法
                system.out.print((char) data);
            }
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

在这个例子中，fis.read() 方法会阻塞，直到读取到数据或文件的末尾。

2.5 网络编程中的阻塞方法

在网络编程中，socket.accept()、socketinputstream.read() 等方法也是阻塞式的。例如，serversocket.accept() 方法会阻塞当前线程，直到有客户端连接到服务器。

import java.io.ioexception;
import java.net.serversocket;
import java.net.socket;

public class serversocketexample {
    public static void main(string[] args) {
        try (serversocket serversocket = new serversocket(8080)) {
            system.out.println("server is listening on port 8080...");
            socket clientsocket = serversocket.accept();  // accept() 是阻塞式方法
            system.out.println("client connected: " + clientsocket.getinetaddress());
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

在这个例子中，serversocket.accept() 方法会阻塞，直到有客户端连接到服务器。

3. 阻塞式方法的优缺点

优点

简单易用：阻塞式方法的逻辑简单、易于理解，开发者不需要处理复杂的异步逻辑或回调。
资源管理容易：由于阻塞式方法通常不会频繁占用cpu资源，因此在处理i/o操作时比较高效。
自然的控制流：阻塞式方法遵循自然的控制流，代码更加直观，不需要分离处理逻辑。

缺点

潜在的性能问题：如果线程长时间阻塞，会导致线程池中的线程被占用，可能导致应用程序的响应能力下降或死锁。
可能导致线程饥饿：在多线程环境中，长时间阻塞可能导致其他线程无法获得执行机会，进而引发线程饥饿问题。
不适用于高并发场景：在高并发应用中，过多的阻塞式方法可能导致线程数量激增，增加内存开销和线程上下文切换的开销。

4. 替代方案：非阻塞式方法与异步编程

由于阻塞式方法的固有缺陷，尤其是在高并发和实时性要求高的系统中，通常会考虑使用非阻塞式方法或异步编程模型。

4.1 非阻塞式i/o

java nio（new i/o）库引入了非阻塞i/o，允许线程在没有数据可用时继续执行其他任务。通过选择器（selector）模型，可以实现一个线程管理多个i/o通道的操作，从而提高并发性能。

import java.io.ioexception;
import java.nio.channels.*;
import java.net.inetsocketaddress;

public class nonblockingserverexample {
    public static void main(string[] args) throws ioexception {
        selector selector = selector.open();
        serversocketchannel serversocketchannel = serversocketchannel.open();
        serversocketchannel.bind(new inetsocketaddress(8080));
        serversocketchannel.configureblocking(false);
        serversocketchannel.register(selector, selectionkey.op_accept);

        while (true) {
            selector.select();
            for (selectionkey key : selector.selectedkeys()) {
                if (key.isacceptable()) {
                    serversocketchannel server = (serversocketchannel) key.channel();
                    socketchannel client = server.accept();
                    client.configureblocking(false);
                    client.register(selector, selectionkey.op_read);
                    system.out.println("connected to client: " + client.getremoteaddress());
                }
                // handle other operations like op_read, op_write
            }
            selector.selectedkeys().clear();
        }
    }
}

4.2 异步编程模型

java的 completablefuture 提供了强大的异步编程支持。通过 completablefuture，你可以在非阻塞的情况下处理异步任务。

import java.util.concurrent.completablefuture;

public class completablefutureexample {
    public static void main(string[] args) {
        completablefuture.supplyasync(() -> {
            try {
                thread.sleep

(2000); // 模拟长时间操作
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
            return "result after 2 seconds";
        }).thenaccept(result -> {
            system.out.println("received: " + result);
        });

        system.out.println("main thread continues...");
    }
}

在这个例子中，异步任务在后台运行，主线程不必等待它完成，可以继续执行其他操作。