两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B...5152Z，要求用线程间通信

两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B…5152Z，要求用线程间通信
使用synchronized或者lock加锁，代码中注释掉的部分是使用lock的方法

1.多线程编写模板:
第一步：定义一个资源类，在类中定义属性和方法
第二步：使用多线程调用资源类中的方法

2.多线程通信模板
第一步：定义资源类，在类中定义属性和方法
第二步：在资源类方法中：
1)判断
2)干活
3)通知
第三步：通过多线程调用资源类中的方法

                     synchronized：                Lock
释放锁等待	           wait()                   condition.await()
唤醒一个等待的线程		   notify()                 condition.signal()
唤醒所有等待的线程        notifyAll()              condition.signalAll()

Lock:比synchronized锁更加强悍的锁

             Lock              	         synchronized
			 更加灵活,轻量级锁[读共享]    重量级锁[读、写排它锁]
			 避免出现死锁                 无法避免出现死锁
			 支持中断                     不支持中断
			 可重入锁                     可重入锁
			 非公平锁|公平锁              非公平锁
			 接口                        关键字
			发生异常时手动释放锁          发生异常时自动释放锁
			 性能高                       性能低

Lock语法：
Lock l = …;
l.lock();
try {
// access the resource protected by this lock
} finally {
l.unlock();
}

package com.atguigu.test;

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

/**
 * 两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B...5152Z，要求用线程间通信
 */
public class test02 {
    static class ThreadExcutation{
        //public Lock lock = new ReentrantLock();
        public Integer flag = 1;
        public int num = 1;
        public int AZ = 65;
        //public Condition conditionNum = lock.newCondition();
        //public Condition conditionAZ = lock.newCondition();

        public synchronized void printNum() throws InterruptedException {
            //lock.lock();
            while (flag != 1) {
                //conditionNum.await();
                this.wait();
            }
            if (num % 2 == 1) {
                System.out.println(num);
                num++;
                flag = 1;
                //conditionNum.signal();
                this.notifyAll();
            }else {
                System.out.println(num);
                num++;
                flag = 2;
                //conditionAZ.signal();
                this.notifyAll();
            }
            //lock.unlock();
        }


        public synchronized void printAZ() throws InterruptedException {
            //lock.lock();
            while (flag != 2) {
                //conditionAZ.await();
                this.wait();
            }
            System.out.println((char)AZ);
            AZ++;
            flag = 1;
            //conditionNum.signal();
            //lock.unlock();
            this.notifyAll();
        }

        public static void main(String[] args) {
            ThreadExcutation threadExcutation = new ThreadExcutation();
            new Thread(()->{
                try {
                    for (int i = 0; i < 52; i++) {
                        threadExcutation.printNum();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
            new Thread(()->{
                try {
                    for (int i = 0; i < 26; i++) {
                        threadExcutation.printAZ();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}