java Thread 示例代码

可以的，以下是一个简单的Java线程示例代码：

public class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread is running");
    }

    public static void main(String args[]) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

以上代码定义了一个名为MyThread的类，该类继承自Thread类。在run方法中，我们可以编写线程要执行的代码。在main方法中，我们实例化了一个MyThread对象，并调用start方法来启动该线程。一旦线程被启动，它将自动调用run方法中的代码。这个简单的示例只是展示了如何创建和启动一个线程，实际上线程的使用远远不止于此。

相关问题

使用Java提供示例代码

以下是使用Java实现可重入锁和公平锁的示例代码：

可重入锁：

import redis.clients.jedis.Jedis;

public class RedisReentrantLock {
    private ThreadLocal<Integer> count = new ThreadLocal<>();
    private ThreadLocal<Long> owner = new ThreadLocal<>();
    private Jedis jedis;
    private String lockKey;

    public RedisReentrantLock(Jedis jedis, String lockKey) {
        this.jedis = jedis;
        this.lockKey = lockKey;
    }

    public boolean acquire() {
        long threadId = Thread.currentThread().getId();
        Integer lockCount = count.get();
        if (lockCount != null && owner.get() == threadId) {
            count.set(lockCount + 1);
            return true;
        }
        boolean acquired = "OK".equals(jedis.set(lockKey, Long.toString(threadId), "NX", "EX", 30));
        if (acquired) {
            owner.set(threadId);
            count.set(1);
        }
        return acquired;
    }

    public boolean release() {
        long threadId = Thread.currentThread().getId();
        if (owner.get() != threadId) {
            throw new IllegalMonitorStateException("Not holding the lock.");
        }
        int lockCount = count.get() - 1;
        count.set(lockCount);
        if (lockCount == 0) {
            jedis.del(lockKey);
            owner.remove();
        }
        return true;
    }
}

公平锁：

import redis.clients.jedis.Jedis;

public class RedisFairLock {
    private ThreadLocal<Long> owner = new ThreadLocal<>();
    private Jedis jedis;
    private String lockKey;
    private String countKey;

    public RedisFairLock(Jedis jedis, String lockKey) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.countKey = lockKey + ":count";
    }

    public boolean acquire() {
        long threadId = Thread.currentThread().getId();
        boolean acquired = false;
        while (!acquired) {
            jedis.rpush(lockKey, Long.toString(threadId));
            while (!jedis.lindex(lockKey, 0).equals(Long.toString(threadId))) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            long count = jedis.incr(countKey);
            if (count == 1) {
                jedis.expire(countKey, 30);
                acquired = true;
            }
        }
        owner.set(threadId);
        return true;
    }

    public boolean release() {
        long threadId = Thread.currentThread().getId();
        if (owner.get() != threadId) {
            throw new IllegalMonitorStateException("Not holding the lock.");
        }
        jedis.lpop(lockKey);
        long count = jedis.decr(countKey);
        if (count == 0) {
            jedis.del(countKey);
        }
        owner.remove();
        return true;
    }
}

以上代码仅供参考，实际使用时需要根据具体情况进行修改和优化。需要注意的是，使用Redis实现分布式锁时，要确保操作的原子性和可靠性，避免死锁和误解锁等问题。

Java CountDownLatch downLoadToLocal 示例代码

Java中的CountDownLatch是一个同步辅助类，它可以让一个或多个线程等待其他线程完成操作后再继续执行。下面是一个示例代码，演示了如何使用CountDownLatch实现文件下载到本地的功能：

import java.util.concurrent.CountDownLatch;

public class FileDownloader {
    public static void main(String[] args) {
        // 创建一个CountDownLatch对象，设置计数器的初始值为1
        CountDownLatch latch = new CountDownLatch(1);

        // 创建一个线程用于下载文件
        Thread downloadThread = new Thread(() -> {
            System.out.println("开始下载文件...");
            // 模拟文件下载过程
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("文件下载完成！");
            // 计数器减1
            latch.countDown();
        });

        // 创建一个线程用于保存文件到本地
        Thread saveThread = new Thread(() -> {
            try {
                // 等待下载线程完成
                latch.await();
                System.out.println("开始保存文件到本地...");
                // 模拟保存文件过程
                Thread.sleep(2000);
                System.out.println("文件保存完成！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 启动下载线程和保存线程
        downloadThread.start();
        saveThread.start();
    }
}

在上述代码中，首先创建了一个CountDownLatch对象，并将计数器的初始值设置为1。然后创建了两个线程，一个用于下载文件，另一个用于保存文件到本地。下载线程在完成文件下载后，通过调用`countDown()`方法将计数器减1。保存线程在执行`await()`方法时会等待计数器变为0，然后开始保存文件到本地。