java lock condition example

最新推荐文章于 2025-04-21 09:59:00 发布

原创最新推荐文章于 2025-04-21 09:59:00 发布 · 160 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

JAVA 专栏收录该内容

89 篇文章

订阅专栏

本文介绍了一个使用Java实现的简单并发缓冲区设计，该设计通过ReentrantLock和Condition来协调生产者和消费者之间的线程同步问题。生产者从文件中读取数据并将其插入到缓冲区，而消费者则从缓冲区读取数据进行处理。


public class FileMock {
    private String content[];
    private int index;

    public FileMock(int size, int length){
        content = new String[size];
        for(int i=0; i<size; i++){
            StringBuilder buffer = new StringBuilder(length);
            for(int j=0; j<length; j++){
                int indice = (int)Math.random() * 255;
                buffer.append((char)indice);
            }
            content[i] = buffer.toString();
        }
        index = 0;
    }

    public boolean hasMoreLines(){
        return index < content.length;
    }

    public String getLine(){
        if(this.hasMoreLines()){
            System.out.println("Mock: " + (content.length-index));
            return content[index++];
        }

        return null;
    }
}


import java.util.LinkedList;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
/**
 * Created by Administrator.
 */
public class Buffer {
    private LinkedList<String> buffer;
    private int maxSize;
    private ReentrantLock lock;
    private Condition lines;
    private Condition space;
    private boolean pendingLines;

    public Buffer(int maxSize){
        this.maxSize = maxSize;
        buffer = new LinkedList<String>();
        lock = new ReentrantLock();
        lines = lock.newCondition();
        space = lock.newCondition();

        pendingLines = true;
    }

    public void insert(String line){
        lock.lock();
        try{
            while(buffer.size() == maxSize){
                space.await();
            }

            buffer.offer(line);
            System.out.printf("%s: Inserted Line: %d\n", Thread.currentThread().getName(), buffer.size());
            lines.signalAll();
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }

    public String get(){
        String line = null;
        lock.lock();
        try{
            while((buffer.size() == 0) && (hasPendingLines())){
                lines.await();
            }

            if(hasPendingLines()){
                line = buffer.poll();
                System.out.printf("%s: Line Readed: %d\n", Thread.currentThread().getName(), buffer.size());
                space.signalAll();
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
        return line;
    }

    public void setPendingLines(boolean pendingLines){
        this.pendingLines = pendingLines;
    }

    public boolean hasPendingLines(){
        return pendingLines || buffer.size() > 0;
    }
}


public class Producer implements Runnable {
    private FileMock mock;
    private Buffer buffer;

    public Producer(FileMock mock, Buffer buffer){
        this.mock = mock;
        this.buffer = buffer;
    }

    @Override
    public void run(){
        buffer.setPendingLines(true);
        while(mock.hasMoreLines()){
            String line = mock.getLine();
            buffer.insert(line);
        }
        buffer.setPendingLines(false);
    }
}


import java.util.Random;

/**
 * Created by Administrator.
 */
public class Consumer implements Runnable {
    private Buffer buffer;
    public Consumer(Buffer buffer){
        this.buffer = buffer;
    }

    @Override
    public void run(){
        while(buffer.hasPendingLines()){
            String line = buffer.get();
            processLine(line);
        }
    }

    private void processLine(String line){
        try{
            Random random = new Random();
            Thread.sleep(random.nextInt(100));
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}


public class Main {
    public static void main(String[] args){
        FileMock mock = new FileMock(100, 10);
        Buffer buffer = new Buffer(20);

        Producer producer = new Producer(mock, buffer);
        Thread threadProducer = new Thread(producer, "Producer");

        Consumer consumers[] = new Consumer[3];
        Thread threadConsumers[] = new Thread[3];
        for(int i=0; i<3; i++){
            consumers[i] = new Consumer(buffer);
            threadConsumers[i] = new Thread(consumers[i], "Consumer " + i);
        }

        threadProducer.start();
        for(int i=0; i<3; i++){
            threadConsumers[i].start();
        }
    }
}