java多线程笔记--synchronized类，对象，方法，代码块

Posted 2022-12-02 SingleOneMan

java多线程笔记–synchronized的用法

文章目录

• java多线程笔记--synchronized的用法
• • • 1.锁对象， 多线程售票示例
    • 2.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();