Java并发编程

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行代码
    }
}
// 使用
MyThread thread = new MyThread();
thread.start();

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行代码
    }
}
// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // 线程执行代码
    }
});

Thread thread = new Thread(() -> {
    // 线程执行代码
});

Callable<String> callable = new Callable<String>() {
    @Override
    public String call() throws Exception {
        return "线程执行结果";
    }
};
FutureTask<String> futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();

public synchronized void method() {
    // 方法体
}

public static synchronized void method() {
    // 方法体
}

synchronized(this) {
    // 同步代码块
}

synchronized(obj) {
    while(条件不满足) {
        obj.wait();
    }
    // 执行操作
    obj.notify(); // 或notifyAll()
}

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
 
lock.lock();
try {
    while(条件不满足) {
        condition.await();
    }
    // 执行操作
    condition.signal(); // 或signalAll()
} finally {
    lock.unlock();
}

jps // 查看Java进程
jstack pid // 查看线程堆栈

ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();

public class MyLock extends AbstractQueuedSynchronizer {
    protected boolean tryAcquire(int arg) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }
 
    protected boolean tryRelease(int arg) {
        setState(0);
        setExclusiveOwnerThread(null);
        return true;
    }
}

// CPU密集型任务
int threadNum = Runtime.getRuntime().availableProcessors();
 
// IO密集型任务
int threadNum = Runtime.getRuntime().availableProcessors() * 2;

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
 
// 活跃线程数
int activeCount = executor.getActiveCount();
// 完成任务数
long completedTaskCount = executor.getCompletedTaskCount();
// 任务总数
long taskCount = executor.getTaskCount();
// 队列大小
int queueSize = executor.getQueue().size();

public class MonitoredThreadPool extends ThreadPoolExecutor {
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        // 执行前记录
    }
 
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        // 执行后记录
    }
}

public class ProducerConsumer {
    private BlockingQueue<Object> queue = new LinkedBlockingQueue<>(10);
 
    public void produce() throws InterruptedException {
        Object object = new Object();
        queue.put(object);
    }
 
    public Object consume() throws InterruptedException {
        return queue.take();
    }
}

public class ProducerConsumer {
    private Queue<Object> queue = new LinkedList<>();
    private int maxSize = 10;
 
    public synchronized void produce() throws InterruptedException {
        while (queue.size() == maxSize) {
            wait();
        }
        queue.offer(new Object());
        notifyAll();
    }
 
    public synchronized Object consume() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();
        }
        Object item = queue.poll();
        notifyAll();
        return item;
    }
}

public class Singleton {
    private volatile static Singleton instance;
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Singleton {
    private Singleton() {}
 
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
 
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

public class CacheService {
    private Map<String, Object> cache = new ConcurrentHashMap<>();
    private Lock lock = new ReentrantLock();
 
    public Object getWithLock(String key) {
        Object value = cache.get(key);
        if (value == null) {
            lock.lock();
            try {
                value = cache.get(key);
                if (value == null) {
                    value = loadFromDB(key);
                    cache.put(key, value);
                }
            } finally {
                lock.unlock();
            }
        }
        return value;
    }
}

public class CacheService {
    public void initCache() {
        // 随机化缓存过期时间
        int expireTime = baseExpireTime + random.nextInt(randomRange);
        // 使用定时任务分散缓存更新
        scheduledExecutor.scheduleWithFixedDelay(() -> {
            updateCache();
        }, expireTime, expireTime, TimeUnit.SECONDS);
    }
}

public class DBPool {
    private GenericObjectPool<Connection> connectionPool;
 
    public void initPool() {
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        config.setMaxTotal(100);
        config.setMaxIdle(10);
        config.setMinIdle(5);
        connectionPool = new GenericObjectPool<>(new ConnectionFactory(), config);
    }
}

public class ShardingService {
    public Connection getConnection(String key) {
        int shardingKey = key.hashCode() % shardingNum;
        return getConnectionBySharding(shardingKey);
    }
 
    public void executeSharding(String sql, Object... params) {
        // 并行执行分片查询
        CompletableFuture<?>[] futures = new CompletableFuture[shardingNum];
        for (int i = 0; i < shardingNum; i++) {
            final int sharding = i;
            futures[i] = CompletableFuture.runAsync(() -> {
                executeInSharding(sql, sharding, params);
            });
        }
        CompletableFuture.allOf(futures).join();
    }
}