/** * 方式二：使用synchronized同步方法解决继承Thread方式解决售票问题中的线程安全问题 * @author wds * @date 2021-11-16-11:20 */ public class ThreadTest03 { public static void main(String[] args) { Thread03 t1 = new Thread03(); Thread03 t2 = new Thread03(); Thread03 t3 = new Thread03(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } class Thread03 extends Thread { private static int ticket = 100; //静态常量数据共享 @Override public void run() { while (true) { show(); } } public static synchronized void show() { //同步方法 if (ticket > 0) { try { Thread.sleep(100); //模拟售票所需要的时间 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在售票，票号为" + ticket); ticket--; } } }

这段代码是一个Java多线程的例子，通过继承Thread类的方式创建了三个线程，分别表示三个售票窗口。在每个线程的run方法中，调用了show方法来模拟售票的过程。而在show方法中，使用了synchronized关键字来保证线程安全，实现了多线程环境下的售票。这种方式相对于继承Thread类的方式，更为简单直观，代码可读性更高。

相关问题

Java模拟生产者/消费者问题，验证线程通过同步等方法解决死锁问题代码

以下是一个使用Java多线程模拟生产者/消费者问题的示例代码，其中使用了同步方法来解决可能出现的死锁问题：

public class ProducerConsumerExample {
    private static Queue<Integer> buffer = new LinkedList<>();
    private static final int BUFFER_SIZE = 10;
    
    public static void main(String[] args) throws InterruptedException {
        Thread producerThread = new Thread(new Producer());
        Thread consumerThread = new Thread(new Consumer());
        
        producerThread.start();
        consumerThread.start();
        
        producerThread.join();
        consumerThread.join();
    }
    
    static class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                try {
                    produce(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        
        private void produce(int i) throws InterruptedException {
            synchronized (buffer) {
                while (buffer.size() == BUFFER_SIZE) {
                    System.out.println("Buffer is full. Waiting for consumer to consume.");
                    buffer.wait();
                }
                
                buffer.add(i);
                System.out.println("Produced " + i);
                buffer.notifyAll();
            }
        }
    }
    
    static class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        
        private void consume() throws InterruptedException {
            synchronized (buffer) {
                while (buffer.isEmpty()) {
                    System.out.println("Buffer is empty. Waiting for producer to produce.");
                    buffer.wait();
                }
                
                int value = buffer.poll();
                System.out.println("Consumed " + value);
                buffer.notifyAll();
            }
        }
    }
}

在这个示例代码中，我们定义了一个缓冲区 `buffer`，使用 `LinkedList` 来实现队列的功能。我们通过两个内部类 `Producer` 和 `Consumer` 来分别模拟生产者和消费者线程。在 `Producer` 内部，我们使用 `synchronized` 关键字来保证在多线程环境下对 `buffer` 的访问是互斥的。当 `buffer` 已满时，生产者线程将等待消费者线程消费一部分数据之后再继续生产。在 `Consumer` 内部同样使用 `synchronized` 关键字来保证对 `buffer` 的访问是互斥的。当 `buffer` 为空时，消费者线程将等待生产者线程生成一些新的数据。

注意，在使用 `wait()` 和 `notifyAll()` 方法时，必须在同步块中调用，否则会抛出 `IllegalMonitorStateException` 异常。

通过这种方式，我们可以保证生产者和消费者线程之间的同步，避免了死锁问题的发生。

使用lock可以解决线程安全问题，并且可以自动释放同步监视器。对不对

是的，使用 `Lock` 接口可以解决线程安全问题，并且可以自动释放同步监视器。

与 `synchronized` 不同，`Lock` 接口提供了更为灵活和细粒度的线程同步机制。使用 `Lock` 接口时，需要显式地获取锁和释放锁，这使得我们可以更好地控制线程的同步和互斥。

在使用 `Lock` 接口时，通常需要定义一个锁对象，然后在需要同步的代码块中使用 `lock()` 方法获取锁，使用 `unlock()` 方法释放锁。与 `synchronized` 类似，如果在获取锁之后发生异常或其他问题导致程序中断，`Lock` 接口也会自动释放锁，避免了死锁等问题。

下面是一个使用 `Lock` 接口的示例代码：

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

public class MyRunnable implements Runnable {
    private Lock lock = new ReentrantLock();

    public void run() {
        lock.lock();
        try {
            // 需要同步的代码块
        } finally {
            lock.unlock();
        }
    }
}

在上面的代码中，定义了一个锁对象 `lock`，然后在 `run()` 方法中使用 `lock()` 方法获取锁，使用 `unlock()` 方法释放锁。这样就可以实现线程的同步和互斥，避免了线程安全问题。