Java多线程编程技巧|开发技术分享-西西软件园




1. 使用wait()和notify()来实现线程间的同步：

```java
public class MyThread {
    private Object lock;
    public MyThread(Object lock){
        this.lock = lock;
    }
    public void run(){
        synchronized (lock){
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread is running...");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Object lock = new Object();
        MyThread thread1 = new MyThread(lock);
        thread1.start();
        synchronized (lock){
            lock.notify();
        }
    }
}
```

2. 使用CountDownLatch来实现线程同步：

```java
public class MyThread extends Thread{
    private CountDownLatch latch;
    public MyThread(CountDownLatch latch){
        this.latch = latch;
    }
    public void run(){
        try {
            latch.await();
            System.out.println("Thread is running...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(1);
        MyThread thread1 = new MyThread(latch);
        thread1.start();
        latch.countDown();
    }
}
```

3. 使用CyclicBarrier来实现线程同步：

```java
public class MyThread extends Thread{
    private CyclicBarrier barrier;
    public MyThread(CyclicBarrier barrier){
        this.barrier = barrier;
    }
    public void run(){
        try {
            barrier.await();
            System.out.println("Thread is running...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(1);
        MyThread thread1 = new MyThread(barrier);
        thread1.start();
        barrier.await();
    }
}
```

4. 使用Semaphore来实现线程同步：

```java
public class MyThread extends Thread{
    private Semaphore semaphore;
    public MyThread(Semaphore semaphore){
        this.semaphore = semaphore;
    }
    public void run(){
        try {
            semaphore.acquire();
            System.out.println("Thread is running...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(1);
        MyThread thread1 = new MyThread(semaphore);
        thread1.start();
        semaphore.release();
    }
}
```
上一篇: Java实现多线程编程的最佳实践下一篇: Java多线程编程实战
西西软件

Java多线程编程技巧

相关推荐

随机推荐

热门专题
