synchronized同步锁这里有点晕，谁能详细解释一下

你要说出具体哪里不大明白，这样笼统的题为即便得到回答也不是针对性的，因为所有答案在视频中都可以找到，这里的答案也是从视频里面得到的，所以你看过之后依然还是不懂，所以你必须有针对性的提出问题，得到针对性的解决之后对你才是有好处的。

synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：
　　public synchronized void accessVal(int newVal);
　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能
执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行
状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有
一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）
。
　　在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成
员变量的访问。
　　synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为
synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可
以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供
了更好的解决办法，那就是 synchronized 块。
synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
　　synchronized(syncObject) {
　　//允许访问控制的代码
　　}
　　 synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机
制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

class TestThread{
        public static void main(String args []){
                myRunnable rn = new myRunnable();
                Thread thread1 = new Thread(rn);
                Thread thread2 = new Thread(rn);
               
                thread1.setName("线程A");
                thread2.setName("线程B");
               
                thread1.start();
                thread2.start();
        }
}



class myRunnable implements Runnable{
        public void run(){
                synchronized (this){
                        for(int i=0;i<100;i++)
                        System.out.println(Thread.currentThread().getName()+i);
                }
                       
                }
}
当线程thread1开启线程时synchronized（this）会将该线程锁定为占用状态 在thread1执行过程中 若thread2想启动该线程 必须等待锁旗标的释放既thread1执行完后thread2才能执行该线程

1.
用synchronized 关键字修饰，代表这个方法加锁,相当于不管哪一个线程每次运行到这个方法时,都要检查有没有其它正在用这个方法的其它线程，有的话要等正在使用synchronized方法的线程运行完这个方法后再运行当前线程,没有的话,直接运行 ，
2.
它包括两种用法：synchronized 方法和 synchronized 块。

首先，先说一下要想保证线程的同步必须满足两个条件。
1.必须有多个线程运行。
2.所用的多个线程必须满足同一把锁。
synchronized同步锁表现形式，同步代码块的锁，synchronized（对象）{}所谓的对象就是锁，当运行多个线程的时候要想保证线程的同步他们所用的对象必须是唯一的。
同步函数使用的锁：1.实例方法是this对象.2静态方法是类
当同步代码块和同步函数同时存在的时候，要想保证线程的同步，线程使用的锁必须要和同步函数使用的锁一致，这样就能保证线程的同步。

好比每一个对象都是一个synchronized，可以同时synchronized多处代码，但是多个线程在操作使用相同对象的synchronized控制的代码的时候，首先需要获取该对象synchronized的操作权限，才能向下执行，而synchronized操作权限，同一时间只能有一个线程能够使用

synchronized的一个简单例子

public class TextThread
{

/**
* @param args
*/
public static void main(String[] args)
{
// TODO 自动生成方法存根
        TxtThread tt = new TxtThread();
        new Thread(tt).start();
        new Thread(tt).start();
        new Thread(tt).start();
        new Thread(tt).start();
}

}
class TxtThread implements Runnable
{
int num = 100;
String str = new String();
public void run()
{
while (true)
{
   synchronized(str)
   {
   if (num>0)
   {
    try
    {
     Thread.sleep(10);
    }
    catch(Exception e)
    {
     e.getMessage();
    }
    System.out.println(Thread.currentThread().getName()+ "this is "+ num--);
   }
   }
}
}
}

上面的例子中为了制造一个时间差,也就是出错的机会,使用了Thread.sleep(10)