java多线程基础学习(三)

接下来是学习synchronized关键字。这是学习线程中非常重要的。它涉及到了线程的同步,异步运行,如何让线程更加安全且快速,这也涉及到了另一个概念,也就是锁。
其实开始学习线程时一定会遇到“线程安全”与“与非线程安全”。

非线程安全:多个线程对同一个对象中的实际变量进行访问时发生,产生的后果就是脏读,也就是取到的数据其实是被更改过的。
线程安全:获得的实际变量是是经过同步处理的,不会出现脏读的现象。
如果多个线程访问一个对象中的实际变量,则有可能出现“非线程安全”问题
这里举个例子
package synchronizedSafe;

public class HasSelfprivateNum 
{
    private int number;
    public void addI(String username)
    {

        {
            if(username.equals("a"))
            {
                number=100;
                System.out.println("a over");
                Thread.sleep(2000);
            }
            else
            {
                number=200;
                System.out.println("b over");
            }
            System.out.println(username+"   number="+number);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}
package synchronizedSafe;

public class ThreadA  extends Thread 
{
    private HasSelfprivateNum numRef;
    public ThreadA(HasSelfprivateNum numRef)
    {
        super();
        this.numRef=numRef;
    }
    public void run()
    {
        super.run();
        numRef.addI("a");
    }
}
package synchronizedSafe;

public class ThreadB extends Thread 
{
    private HasSelfprivateNum numRef;
    public ThreadB(HasSelfprivateNum numRef)
    {
        super();
        this.numRef=numRef;
    }
    public void run()
    {
        super.run();
        numRef.addI("b");
    }
}
package synchronizedSafe;

public class Run {

    public static void main(String[] args) 
    {
        HasSelfprivateNum hp=new HasSelfprivateNum();
        ThreadA thA=new ThreadA(hp);
        thA.start();
        ThreadB thB=new ThreadB(hp);
        thB.start();
    }

}
搜狗截图18年04月05日2122_2.png
本实验是两个线程同时访问一个没有同步的方法,如果两个线程同时操作业务对象中的实际变量,则有可能会出现“非线程安全”问题。如果是实现同步,在public void addI(String username)前面加入关键字synchronized

在Java里边就是拿到某个同步对象的锁(一个对象只有一把锁);
如果这个时候同步对象的锁被其他线程拿走了,他(这个线程)就只能等了(线程阻塞在锁池等待队列中)。
取到锁后,他就开始执行同步代码(被synchronized修饰的代码);
线程执行完同步代码后马上就把锁还给同步对象,其他在锁池中等待的某个线程就可以拿到锁执行同步代码了。
这样就保证了同步代码在统一时刻只有一个线程在执行。
简单是来说就是谁拿到同一个对象锁能就运行关键字synchronized的代码快
举一个例子,把上面的main方法改成下面这样
先在上面的public void addI(String username)前面加入关键字synchronized
    public static void main(String[] args) 
    {
        HasSelfprivateNum hp=new HasSelfprivateNum();
        HasSelfprivateNum hp1=new HasSelfprivateNum();
        ThreadA thA=new ThreadA(hp);
        thA.start();
        ThreadB thB=new ThreadB(hp1);
        thB.start();
    }
这样虽然加了关键字synchronized,但是两个线程所持有的并不是一个对象的锁,所有线程是异步执行而不是同步。
关键字synchronized取得的锁都是对象锁,而不是一段代码或者方法当做锁。哪个线程先执行带#####synchronized关键字的方法,哪个线程就持有该方法所属对象的锁LOCK,那么其他线程只能处于等待状态,前提是多个线程访问的是同一个对象。接下来是使用方法
package jianshu;

public class MyObject 
{
    synchronized public void test()
    {
        try
        {
            System.out.println("begin method Threadname="+Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}
package jianshu;

public class ThreadA extends Thread 
{
    MyObject mb;
    public ThreadA(MyObject mb)
    {
        super();
        this.mb=mb;
    }
    public void run()
    {
        mb.test();
    }
}
package jianshu;

public class ThreadB extends Thread 
{
    MyObject mb;
    public ThreadB(MyObject mb)
    {
        super();
        this.mb=mb;
    }
    public void run()
    {
        mb.test();
    }
}
package jianshu;

public class Run {

    public static void main(String[] args)
    {
        MyObject mb=new MyObject();
        ThreadA ta=new ThreadA(mb);
        ta.setName("A");
        ta.start();
        ThreadB tb=new ThreadB(mb);
        tb.setName("B");
        tb.start();
        
    }

}
搜狗截图18年04月06日2004_1.png
控制台得到的结果是,先是A线程执行完毕后,才开始B线程的执行。也就是说声明调用synchronized关键字的方法一定是排队运行的(这就是同步运行)。如果你去除synchronized关键字那么即使异步运行
另外需要牢牢记住"共享"这两个字,只有共享资源的读写访问才需要同步化,换句话说不说共享资源,就没有同步的必要。

接下来再来一个例子
在MyObject.java文件中创建一个新的方法

    public void test1()
    {
        try
        {
            System.out.println("begin method Threadname="+Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
    }

然后在线程B只调用新方法。


搜狗截图18年04月06日2015_2.png

然后其结果是异步进行的。可根据结论得到

1.A线程持有Object对象的锁,B线程可以以异步的方式调用Object对象中的非synchronized类型的方法
2.A线程持有Object对象的锁,B线程如果在这时调用有synchronized类型的方法则需要等待,也就是同步

脏读

读取实际变量时,此值已经被其他线程修改过了。也就是取到过期的值

package example;

public class PublicVar 
{
    public String username="A";
    public String password="AA";
    synchronized public void setValue(String username,String password)
    {
        try
        {
            this.username=username;
            Thread.sleep(5000);
            this.password=password;
            System.out.println("Setvalue mothod Thread name="+Thread.currentThread().getName()+"  username="+username+"  password="+password);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    
     public void getValue()
    {
        System.out.println("Setvalue mothod Thread name="+Thread.currentThread().getName()+"  username="+username+"  password="+password);
    }
}
package example;

public class ThreadA extends Thread
{
    private PublicVar publicvar;
    public ThreadA(PublicVar publicvar)
    {
        this.publicvar=publicvar;
    }
    public void run()
    {
        super.run();
        publicvar.setValue("B", "BB");
    }
}
package example;

public class Run {

    public static void main(String[] args) throws InterruptedException 
    {
        PublicVar pv=new PublicVar();
        ThreadA ta=new ThreadA(pv);
        ta.start();
        //打印结果受此值影响
        Thread.sleep(200);
        pv.getValue();
    }

}
搜狗截图18年04月06日2031_3.png
出现脏读的情况是getValue()方法并不同步,所以可以在任何时候进行调用,解决方法就是加入synchronized关键字。
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容