synchronized

线程

并发原理
微观上是走走停停的，宏观上都在运行。这种现象叫并发，因此不是绝对意义上的“同时运行”操作系统将时间划分为很多时间片段(时间片）,尽可能均匀分配给每一个线程，得到时间片段的线程被CPU运行，而其他线程全部等待，CPU在用高性能模拟“同时”，线程可以多个代码片段"同时运行"。实际上是并发运行。

创建线程有两种方式:
1:定义一个类继承Thread并重写run方法。run方法中定义线程要执行的任务代码

第一种创建线程的方式优点在于:  结构简单，直接。利于匿名内部类形式创建。
缺点︰
1:由于java是单继承的，这会导致如果继承了Thread就不能再继承其他的类去复用方法，这在实际开发中是非常不方便的。
2:重写了run方法意味着将线程要执行的任务定义在了线程中，这导致线程写茬务荐在必然的耦合关系，不利于线程的重用。
第二种创建线程的方式
实现Runnable接口单独定义线程任务

多线程并发的安全问题
当多个线程并发操作同一临界资源，由于线程切换的实际不确定，导致操作顺序出现混乱。严重时可能出现系统瘫痪等问题。总结起来就是多线程抢同一个东西导致的混乱。
临界资源:操作过程只能被单线程进行的资源。

当一个方法使用synchronized修饰后，这个方法成为同步方法，即:多个线程不能同时在方法内部执行。
将多线程并发操作临界资源改为同步执行可以解决并发安全问题。

同步块
  语法:
  synchronized(同步监视器对象){
      需要同步运行的代码片段
  }
 

有效的缩小同步范围可以在保证并发安全的前提下提高并发效率

  在方法上使用synchronized时，同步监视器对象就是当前方法所属对象
        即:this
     /
//    public synchronized void buy(){
    public void buy(){
        try{
            Thread t = Thread.currentThread();
            System.out.println(t.getName()+":正在挑衣服...");
            Thread.sleep(5000);
            /
                同步块使用时要指定同步监视器对象，它可以是java中任何类的
                实例，但是必须保证多个需要同步运行该代码块的线程看到的这个
                对象是同一个才行。
             /
//            synchronized (new Object()) {//该同步监视器对象无效
            synchronized (this) {
                System.out.println(t.getName() + ":正在试衣服...");
                Thread.sleep(5000);
            }
            System.out.println(t.getName()+":结账离开!");
        }catch(InterruptedException e){
        }
    }

静态方法上如果使用synchronized修饰后，该方法一定具有同步效果。
静态方法上使用的锁对象(同步监视器对象)是当前类的类对象，一个Class的实例

 public static void dosome(){
        //指定类对象作为同步监视器时的写法:当前类的类名.class
        synchronized (Boo.class) {
            Thread t = Thread.currentThread();
            System.out.println(t.getName() + ":正在执行dosome方法...");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(t.getName() + ":执行dosome方法完毕!");
        }
    }

 下面的互斥锁与死锁 还没理解透 先把代码放着  请大佬指教“”“

/**
 * 互斥锁
 * 当使用synchronized锁定多个代码片段，并且指定的锁对象相同时，这些代码
 * 就是互斥的，多个线程不能同时执行他们。
 */
public class SyncDemo4 {
    public static void main(String[] args) {
        Foo foo = new Foo();
        Thread t1 = new Thread(){
            public void run(){
                foo.methodA();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                foo.methodB();
            }
        };
        t1.start();
        t2.start();
    }
}

class Foo{
    public synchronized void methodA(){
        Thread t = Thread.currentThread();
        System.out.println(t.getName()+":正在执行A方法");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t.getName()+":执行A方法完毕");
    }
    public void methodB(){
        synchronized (this) {
            Thread t = Thread.currentThread();
            System.out.println(t.getName() + ":正在执行B方法");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(t.getName() + ":执行B方法完毕");
        }
    }
}

/**
 * 死锁
 * 当线程之间都持有一个自己的锁并在过程中等待对方释放锁，此时会出现一个僵持
 * 状态，这个过程会一直持续。这个现象称为死锁
 *
 */
public class DeadLockDemo {
    private static Object chopstick = new Object();//筷子
    private static Object spoon = new Object();;//勺
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            public void run(){
                try {
                    System.out.println("北方人开始吃饭...");
                    synchronized (chopstick) {
                        System.out.println("北方人拿起了筷子吃饭...");
                        Thread.sleep(5000);
                        System.out.println("北方人吃完饭了!");
                        synchronized (spoon){
                            System.out.println("北方人拿起了勺喝汤...");
                            Thread.sleep(5000);
                            System.out.println("北方人喝完汤了!");
                        }
                        System.out.println("北方人放下了勺");
                    }
                    System.out.println("北方人放下了筷子");
                    System.out.println("北方人吃饭完毕!");
                }catch(Exception e){}
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                try {
                    System.out.println("南方人开始吃饭...");
                    synchronized (spoon) {
                        System.out.println("南方人拿起了勺喝汤...");
                        Thread.sleep(5000);
                        System.out.println("南方人喝完汤了!");
                        synchronized (chopstick){
                            System.out.println("南方人拿起了筷子吃饭...");
                            Thread.sleep(5000);
                            System.out.println("南方人吃完饭了!");
                        }
                        System.out.println("南方人放下了筷子");
                    }
                    System.out.println("南方人放下了勺");
                    System.out.println("南方人吃饭完毕!");
                }catch(Exception e){}
            }
        };
        t1.start();
        t2.start();

        /*
            解决:
            1:避免在synchronized块中嵌套synchronized
            2:当锁定一个对象后，在跟它相关的操作进行完毕后就应当及时
              释放(缩小同步范围到适当位置)
         */
//        Thread t1 = new Thread(){
//            public void run(){
//                try {
//                    System.out.println("北方人开始吃饭...");
//                    synchronized (chopstick) {
//                        System.out.println("北方人拿起了筷子吃饭...");
//                        Thread.sleep(5000);
//                        System.out.println("北方人吃完饭了!");
//                    }
//                    System.out.println("北方人放下了筷子");
//                    synchronized (spoon){
//                        System.out.println("北方人拿起了勺喝汤...");
//                        Thread.sleep(5000);
//                        System.out.println("北方人喝完汤了!");
//                    }
//                    System.out.println("北方人放下了勺");
//                    System.out.println("北方人吃饭完毕!");
//                }catch(Exception e){}
//            }
//        };
//        Thread t2 = new Thread(){
//            public void run(){
//                try {
//                    System.out.println("南方人开始吃饭...");
//                    synchronized (spoon) {
//                        System.out.println("南方人拿起了勺喝汤...");
//                        Thread.sleep(5000);
//                        System.out.println("南方人喝完汤了!");
//                    }
//                    System.out.println("南方人放下了勺");
//                    synchronized (chopstick){
//                        System.out.println("南方人拿起了筷子吃饭...");
//                        Thread.sleep(5000);
//                        System.out.println("南方人吃完饭了!");
//                    }
//                    System.out.println("南方人放下了筷子");
//
//                    System.out.println("南方人吃饭完毕!");
//                }catch(Exception e){}
//            }
//        };

    }
}