分别采用临界区与Lock加锁方式完成两个子线程之间的互斥。在主线程中使用thread创建两个子线程，通过synchronized构造临界区并使两个子线程互斥使用打印进程。采用Lock加锁方式使两个子线程互斥使用全局变量count。

在Java中，可以分别使用`synchronized`关键字和`java.util.concurrent.locks`包中的`Lock`接口来实现子线程间的互斥访问。

**1. 使用`synchronized`（临界区）**

public class SynchronizedExample {
    private int count = 0;

    public void printCount() {
        synchronized (this) { // 使用当前对象作为锁
            if (count % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + count++);
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        Thread t1 = new Thread(() -> example.printCount());
        Thread t2 = new Thread(() -> example.printCount());
        
        t1.start(); // 线程A启动
        t2.start(); // 线程B启动
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，`printCount`方法内部的`synchronized`块保证了只有一个线程能同时执行这个方法，实现了互斥。

**2. 使用`Lock`（ReentrantLock）**

import java.util.concurrent.locks.ReentrantLock;

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

    public void printCount() {
        lock.lock(); // 获取锁
        try {
            if (count % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + count++);
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public static void main(String[] args) {
        LockExample example = new LockExample();
        Thread t1 = new Thread(() -> example.printCount());
        Thread t2 = new Thread(() -> example.printCount());

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

在这里，我们使用`ReentrantLock`代替`synchronized`，线程需要显式地调用`lock()`获取锁，结束后调用`unlock()`释放锁，提供了更多的控制选项和更好的并发性能。