Java学习之多线程（线程安全问题及线程同步）

一、线程安全问题产生前提：
1、多线程操作共享数据
2、线程任务中有多条代码

class Ticket implements Runnable
{
    //2.共享数据
    private int num = 100;
    
    public void run()
    {
        while(true)
        {
            //3.多条代码
            if(num > 0)
            {
                try{Thread.sleep(10);}catch(InterruptedException e){}
                System.out.println(Thread.currentThread().getName()+"==="+num--);
            }
        }
    }
}

class TicketDemo
{
    public static void main(String[] args)
    {
        Ticket t = new Ticket();
        //1.多线程操作同一个对象
        Thread t1 =new Thread(t);
        Thread t2 =new Thread(t);
        Thread t3 =new Thread(t);
        Thread t4 =new Thread(t);
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行结果：

 出现线程安全问题了

二、解决线程安全问题

解决线程安全问题的两种方式：

①、同步代码块

格式：

synchronized(对象)
{
 　　//需要被同步的代码;
    ... ...  
}

解决上面线程安全问题的代码：

class Ticket implements Runnable
{
    //2.共享数据
    private int num = 100;
    //同步锁：对象
    private Object o=new Object();
    public void run()
    {
        while(true)
        {
            synchronized(o)
            {
                //3.多条代码
                if(num > 0)
                {
                    try{Thread.sleep(10);}catch(InterruptedException e){}
                    System.out.println(Thread.currentThread().getName()+"==="+num--);
                }
            }
        }
    }
}

结果：

解决原理：多线程在使用同步代码块时，使用了同一个同步锁（Object的对象）

②、同步函数

格式： 

public synchronized 方法返回值类型 方法名(参数列表) 
{ 
 ... ... 
}

2.1、非静态同步函数

代码：

class Ticket implements Runnable
{
    //2.共享数据
    private int num = 100;
    //同步锁：对象
    //private Object o=new Object();
    public void run()
    {
        while(true)
        {
            /*
            synchronized(o)
            {
                //3.多条代码
                if(num > 0)
                {
                    try{Thread.sleep(10);}catch(InterruptedException e){}
                    System.out.println(Thread.currentThread().getName()+"==="+num--);
                }
            }
            */
            show();
        }
    }
    public synchronized void show()
    {
        //3.多条代码
        if(num > 0)
        {
            try{Thread.sleep(10);}catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()+"==="+num--);
        }
    }
}

结果：

2.2、静态同步函数

代码：

class Ticket implements Runnable
{
    //2.共享数据
    private static int num = 100;
    //同步锁：对象
    //private Object o=new Object();
    public void run()
    {
        while(true)
        {
            /*
            synchronized(o)
            {
                //3.多条代码
                if(num > 0)
                {
                    try{Thread.sleep(10);}catch(InterruptedException e){}
                    System.out.println(Thread.currentThread().getName()+"==="+num--);
                }
            }
            */
            show();
        }
    }
    public static synchronized void show()
    {
        //3.多条代码
        if(num > 0)
        {
            try{Thread.sleep(10);}catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()+"==="+num--);
        }
    }
}

结果：

 

总结：

同步的好处：解决线程的安全问题
同步的弊端：效率低，因为同步外的线程都会判断同步锁

同步的前提：必须有多个线程使用同一个同步锁（synchronized(同步锁：对象)）

同步代码块：可以指定任意对象作为同步锁

同步函数：非静态同步函数的同步锁为当前类对象（this），静态同步函数为当前类的字节码对象（类名.class或this.getClass()）