实现两个线程交替打印数字和字母的同步机制

### 1. 使用同步方法实现

在本示例中，我们将通过同步方法来控制两个线程的执行顺序。具体代码如下：

```java
package Synchronized;

public class PrintTest {
public static void main(String[] args) {
Print p = new Print();
Thread t1 = new PrintNumber(p);
Thread t2 = new PrintWord(p);
t1.start();
t2.start();
}
}

// 打印数字线程
class PrintNumber extends Thread {
private Print p;

public PrintNumber(Print p) {
this.p = p;
}

@Override
public void run() {
for (int i = 0; i <26; i++) {
p.printNumber();
}
}
}

// 打印字母线程
class PrintWord extends Thread {
private Print p;

public PrintWord(Print p) {
this.p = p;
}

@Override
public void run() {
for (int i = 0; i <26; i++) {
p.printWord();
}
}
}

// 同步监视器类
class Print {
private int num = 1;
private char letter = 'A';

public synchronized void printNumber() {
System.out.print(num + (num + 1));
num += 2;
notifyAll();
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

public synchronized void printWord() {
System.out.print(letter);
letter++;
notifyAll();
try {
if (letter <= 'Z') {
wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
```

### 2. 使用同步代码块实现

接下来，我们使用同步代码块来实现同样的功能。代码如下：

```java
package threaddemo;

public class ThreadDemo {
public static void main(String[] args) throws Exception {
Object lock = new Object();
Thread1 t1 = new Thread1(lock);
Thread2 t2 = new Thread2(lock);
t1.start();
t2.start();
}
}

// 打印1-52的线程
class Thread1 extends Thread {
private final Object lock;

public Thread1(Object lock) {
this.lock = lock;
}

@Override
public void run() {
synchronized (lock) {
for (int i = 1; i <= 52; i++) {
System.out.print(i + " ");
if (i % 2 == 0) {
lock.notifyAll();
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}

// 打印A-Z的线程
class Thread2 extends Thread {
private final Object lock;

public Thread2(Object lock) {
this.lock = lock;
}

@Override
public void run() {
synchronized (lock) {
for (int i = 0; i <26; i++) {
System.out.print((char) ('A' + i) + " ");
lock.notifyAll();
try {
if (i != 25) {
lock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
```

### 总结

通过上述两种方式，我们可以有效地控制两个线程的执行顺序，确保它们按照指定的模式交替打印数字和字母。同步方法和同步代码块各有优劣，在实际开发中可以根据需求选择合适的方式。