接下来是学习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
