java多线程笔记–synchronized的用法

* 0）对象锁是用于对象实例方法，或者一个对象实例上的，
* 类锁是用于类的静态方法或者一个类的class对象上的（单例模式的双重检测）
* 一个线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁
* 1)synchronized类,和synchronized对象（this）
* //synchronized(this)代表锁住同一对象。多个线程竞争锁访问同一对象，对不同对象不竞争
* //synchronized(CountRunnable.class)代表锁住整个CountRunnable类的对象。多个线程对同一类的多个对象也竞争锁访问
* 2）synchronized方法和synchronized代码块
* 同步代码块比同步方法粒度小；一般需要加锁进行同步的时候，肯定是范围越小越好，这样性能更好
* synchronized方法和synchronized代码块(synchronized(this))都是锁当前对象
* 3）当一个线程访问object的一个synchronized(this)同步代码块时，
* 另一个线程仍然可以访问该object中的非synchronized(this)同步代码块
* 4)线程访问synchronized内的代码时，会隐式地获取锁，执行完括号中的代码，会隐式地释放锁

1.锁对象， 多线程售票示例

package com.ctg.test.thread;

/**
 * @Description: 1)synchronized 类
 * 2）synchronized对象（this）
 * 3）synchronized方法
 * 4）synchronized代码块
 * @Author: 
 * @Date: 2019/5/22 21:48
 */
public class TestSynchronizedTicket {
    private static int num = 10;

    public static void main(String[] args) {
        TicketRunnable ticketRunnable = new TicketRunnable(num);
        Thread t1 = new Thread(ticketRunnable, "窗口1");
        Thread t2 = new Thread(ticketRunnable, "窗口2");
        Thread t3 = new Thread(ticketRunnable, "窗口3");
        t1.start();
        t2.start();
        t3.start();

    }

    public static class TicketRunnable implements Runnable {
        private int ticket;

        public TicketRunnable(int ticket) {
            this.ticket = ticket;
        }

        @Override
        public void run() {
            while (ticket > 0) {
                //锁对象，多个线程竞争访问同一个对象TicketRunnable ticketRunnable = new TicketRunnable(num)
                synchronized (this) {
                    if (ticket > 0) {
                        try {
                            ticket--;
                            Thread.sleep(100);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在卖票，还剩：" + ticket);
                    }else{
                        System.out.println(Thread.currentThread().getName() + "票已卖完" );

                    }

                }

            }

        }
    }
}

2.synchronized类，对象，方法，代码块示例

package com.ctg.test.thread;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Description:

 * @Author:
 * @Date: 2019/5/22 23:34
 */
public class Service {
    //类锁，锁 静态方法,和f2 f3不竞争
    public static synchronized void f0(){
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        System.out.println(df.format(new Date())+";"+Thread.currentThread().getName()+":"+"f0");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //类锁，锁 类.class,和f2 f3不竞争
    public void f1(){
        synchronized (Service.class) {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            System.out.println(df.format(new Date())+";"+Thread.currentThread().getName()+":"+"f1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //锁方法，f2 f3竞争(锁的也是当前对象)
    public synchronized void f2(){
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        System.out.println(df.format(new Date())+";"+Thread.currentThread().getName()+":"+"f2");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //锁代码块，f2 f3竞争，如果用了同步代码块，那么当退出代码块时就已经释放了对象锁(当前对象this进行加锁)
    public void f3(){
        //
        synchronized (this) {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            System.out.println(df.format(new Date())+";"+Thread.currentThread().getName()+":"+"f3");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //
    }
    //锁普通对象,跟f2 f3不竞争
    public void f4(){
        String str="test";
        synchronized (str) {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            System.out.println(df.format(new Date())+";"+Thread.currentThread().getName()+":"+"f4");
        }
    }

}

测试：

package com.ctg.test.thread;

/**
 * @Description:
 * 0）对象锁是用于对象实例方法，或者一个对象实例上的，
 * 类锁是用于类的静态方法或者一个类的class对象上的（单例模式的双重检测）
 * 一个线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁
 * 1)synchronized类,和synchronized对象（this）
 * //synchronized(this)代表锁住同一对象。多个线程竞争锁访问同一对象，对不同对象不竞争
 * //synchronized(CountRunnable.class)代表锁住整个CountRunnable类的对象。多个线程对同一类的多个对象也竞争锁访问
 * 2）synchronized方法和synchronized代码块
 * 同步代码块比同步方法粒度小；一般需要加锁进行同步的时候，肯定是范围越小越好，这样性能更好
 * synchronized方法和synchronized代码块(synchronized(this))都是锁当前对象
 * 3）当一个线程访问object的一个synchronized(this)同步代码块时，
 * 另一个线程仍然可以访问该object中的非synchronized(this)同步代码块
 * 4)线程访问synchronized内的代码时，会隐式地获取锁，执行完括号中的代码，会隐式地释放锁
 * @Author: 
 * @Date: 2019/5/22 21:48
 */
public class TestSynchronized {
    /**
     * 执行结果：f0 f1竞争访问，类锁，和f4不竞争锁
     * f2 f3竞争访问对象锁，和f4不竞争锁
     * @param args
     */
    public static void main(String[] args) {
        Service service=new Service();
        Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                Service.f0();
            }
        },"线程0");

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                service.f1();
            }
        },"线程1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                service.f2();
            }
        },"线程2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                service.f3();
            }
        },"线程3");
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                service.f4();
            }
        },"线程4");
        t0.start();
        t1.start();
//        t2.start();
//        t3.start();
//        t4.start();

    }

}