java 各种锁的使用

Java中的Runnable接口允许类实现多线程。使用Runnable接口可以避免继承Thread类的限制。要使用Runnable接口，需要实现run()方法，并将实现类的实例传递给Thread类的构造函数。例如：

class MyRunnable implements Runnable {
    public void run() {
        // code to be executed in separate thread
    }
}

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

另外，在Java8之后，可以使用Lambda表达式简化Runnable接口的使用

Thread thread = new Thread(() -> {
    // code to be executed in separate thread
});
thread.start();

相关问题

java使用线程锁

在 Java 中，使用线程锁可以避免多个线程同时修改共享资源时出现的并发问题。Java 中提供了多种锁机制，其中最常用的是 synchronized 关键字和 ReentrantLock 类。

使用 synchronized 关键字可以将一段代码或方法标记为同步代码块，这样在同一时刻只有一个线程可以执行该代码块。示例代码如下：

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

在这个示例中，increment() 和 getCount() 方法都被标记为 synchronized，这意味着任何时候只有一个线程可以执行这些方法。这样可以确保 count 变量的值不会被多个线程同时修改。

另外，Java 还提供了 ReentrantLock 类，它实现了 Lock 接口，提供了更灵活的锁机制。使用 ReentrantLock 时，需要手动获取锁和释放锁，示例代码如下：

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

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

在这个示例中，increment() 和 getCount() 方法分别使用了 lock.lock() 和 lock.unlock() 方法获取和释放锁。和 synchronized 关键字不同，使用 ReentrantLock 可以更灵活地控制锁的获取和释放，但需要更多的代码来处理锁的逻辑。

java mysql 悲观锁使用

Java程序可以通过使用数据库悲观锁来防止多个线程同时对同一个MySQL数据进行修改。悲观锁是指在读取一行数据时，将该行数据加上排他锁或共享锁，从而阻塞其他线程的对该行数据的操作。MySQL的InnoDB存储引擎支持行级别的悲观锁机制。

Java程序可以使用“SELECT FOR UPDATE”语句实现悲观锁。此时，该语句会将选定数据行的行锁加到数据表的行上。该语句可以用来锁定整个表，也可以锁定表中的特定行。

另一种方法是使用“SELECT ... LOCK IN SHARE MODE”语句。该语句将选定数据行的共享锁加到数据表的行上，防止其他线程的修改操作。该语句可以用来锁定整个表，也可以锁定表中的特定行。