多线程时synchronized到底应该锁定什么对象？

import org.junit.Test;

import java.sql.Timestamp;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * @Description: synchronized加锁的对象测试
 * @date: 2020-02-20 16:38
 * @author: yff
 */

/*
* synchronized
*   1，锁定普通方法时，锁定的是当前对象，仅对当前对象生效，当不同对象(用new创建出来的对象)，来执行代码时，不能锁定代码，不能保证只有一个线程进入
*   2，锁定static时，锁定的是class类，不管创建几个相同类的对象来执行代码，都只能有一个线程进入
*   3（实验目的），锁定特定对象时，只能是最先拥有这个对象的线程才能进入
*先说一下业务要求：一次请求，在后台生成多线程同时查库，然后把多个查库的结果同时塞入map中。全程没有写库的操作。
*例如代码中，通过主类启动两个线程（模拟两个请求），每个请求创建各自的线程池处理各自的业务（互不能影响），各自的线程池再创建各自的两（多）个Runnable任务（提升效率）。
* 注意：TestRunnable中的map是临界资源
*总计两个线程池     pool1   与   pool  2  ,
*   四个线程  pool1-thread-1    pool1-thread-2   pool2-thread-1    pool2-thread-2
*   ①当synchronized锁定this对象时：四个线程能相互影响，数据完全混乱，不符合业务要求
*   ②当synchronized锁定TestRunnable.class类时:四个线程全都相互排斥，能保证数据安全
*但是多线程的目的原本是想让一个请求（线程池）中的两个线程相互协调提升效率。如果这样加锁，
*就会造成请求A在操作临界资源时，虽然可以让相同线程池中的其他线程排队等待，但是也会使其他请求中的多个线程也一并在外排队等待。
*而实际情况是，每次请求都会声明一个map，多个请求之间并不会相互影响，因为它们操作两个map。
*   ③当synchronized锁定map时：同一个线程池中的线程相互等待，不同线程池的线程可以同时执行代码块。这也恰好符合业务逻辑，
*每个请求声明多个线程同时协作，在临界资源时等待。不同请求由于操作的资源不是同一个，所以不必相互等待（指的是塞入的不是一个map，但如果有写库场景的话需要等待）。
*把库看成map，如果写入操作是一个临界资源，则要等待，相当于一个线程池中的线程相互等待，如果写入的是多个map，则可以看成多个库，自然不用相互等待，道理都是一样的，活学活用吧。
* */
public class Main {


    @Test
    public void main() {
        Thread testThread = new TestThread();
        testThread.setName("启动线程1");
        testThread.start();
        Thread testThread2 = new TestThread();
        testThread2.setName("启动线程2");
        testThread2.start();
        try {
            testThread.join();
            testThread2.join();
        } catch (InterruptedException e) {
            System.err.println("error!!!!!!!!!");
        }finally {
            System.out.println("main结束了");
        }
    }


    class TestThread extends Thread {
        @Override
        public void run() {
            Executor executor;
            synchronized (TestThread.class){
                System.out.println(new Timestamp(System.currentTimeMillis())+Thread.currentThread().getName()+"先进入了run创建了pool");
                executor = Executors.newFixedThreadPool(4);
            }
            Map map = new HashMap(4);
            map.put("key1", "value1");
            map.put("key2", "value2");
            Runnable t1 = new TestRunnable(map);
            Runnable t2 = new TestRunnable(map);
            executor.execute(t1);
            executor.execute(t2);
            try {
                ((ExecutorService) executor).shutdown();
                boolean flag;
                while (true) {
                    flag = ((ExecutorService) executor).awaitTermination(4, TimeUnit.SECONDS);
                    if (flag) {
                        System.out.println(new Timestamp(System.currentTimeMillis())+Thread.currentThread().getName()+"终于执行完了");
                        break;
                    }else{
                        System.out.println(new Timestamp(System.currentTimeMillis())+Thread.currentThread().getName()+"还没有执行完");
                    }
                }
            } catch (InterruptedException e) {
                System.err.println("error!!!!!!!!!!!");
            } finally {
                System.out.println(new Timestamp(System.currentTimeMillis())+Thread.currentThread().getName()+"Thread结束了");
            }
        }
    }

    class TestRunnable implements Runnable {

        private Map map;

        public TestRunnable(Map map) {
            this.map = map;
        }

        @Override
        public void run() {
            synchronized (map) {
                try {
                    System.out.println(new Timestamp(System.currentTimeMillis())+Thread.currentThread().getName()+"线程开始睡眠3秒");
                    Thread.sleep(3000);
                    System.out.println(new Timestamp(System.currentTimeMillis())+Thread.currentThread().getName()+"线程结束睡眠3秒");
                } catch (InterruptedException e) {
                    System.err.println("error!!!!!!!");
                }
            }
        }
    }

}