多线程同时访问一个资源，可以会产生不可预料的结果，所以为这个资源加锁,访问资源的第一个线程为其加锁后，其他线程便不能在使用那个资源，直到锁被解除。
举个例子：
存款1000元，能取出800的时候我就取800，当我同时用两个线程调用这个取钱操作时，有时可以取出1600元
static class HelloRunable implements Runnable{
private int money = 1000;
//取出800元
int getMoney() {
System.out.println("开始" + money);
if(money > 800) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
money -= 800;
System.out.println("我取了800元" + money);
}
System.out.println("结束" + money);
return money;
}
@Override
public void run() {
money = getMoney();
}
}
public static void main(String[] args) {
HelloRunable helloRunable = new HelloRunable();
Thread t = new Thread(helloRunable);
Thread t1 = new Thread(helloRunable);
t.start();
t1.start();
}
synchronized：
所以我们引入了同步机制，在取钱方法前面加入了synchronized关键字，该方法称为同步方法，输出结果为
java中每个对象都有一个锁，或者叫做监视器(monitor),当一个线程访问某个对象的synchronized方法时，将该对象上锁，其他任何线程都无法再去访问该对象的synchronized方法，直到之前的那个线程执行完方法之后，才会将对象锁释放，其他线程才可以在用该对象的synchronized方法。 注：这是给对象上锁，如果是不同的对象则该对象之间没有限制关系。
如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了synchronized方法，那么在该方法没有执行完前，其他线程是无法访问该对象的任何synchronized方法的。
例如：
public static void main(String[] args)
{
Example example = new Example();
Thread t1 = new Thread1(example);
Thread t2 = new Thread2(example);
t1.start();
t2.start();
}
static class Example
{
public synchronized void execute()
{
for (int i = 0; i < 20; ++i)
{
try
{
Thread.sleep((long) Math.random() * 1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("Hello: " + i);
}
}
public void execute2()
{
for (int i = 0; i < 20; ++i)
{
try
{
Thread.sleep((long) Math.random() * 1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("World: " + i);
}
}
}
static class Thread1 extends Thread
{
private Example example;
public Thread1(Example example)
{
this.example = example;
}
@Override
public void run()
{
example.execute();
}
}
static class Thread2 extends Thread
{
private Example example;
public Thread2(Example example)
{
this.example = example;
}
@Override
public void run()
{
example.execute2();
}
}
当加上synchronized后,当同步方法未执行完时另一个同步方法不会执行
静态的同步方法
当一个synchronized关键字修饰的方法同时被static修饰，非静态的同步方法会将对象上锁，但是静态方法不属于对象，而是属于类，他会将这个方法所在的类的Class对象上锁。
public static void main(String[] args)
{
Example example = new Example();
Thread t1 = new Thread1(example);
example = new Example();
Thread t2 = new Thread2(example);
t1.start();
t2.start();
}
static class Example
{
public static synchronized void execute()
{
for (int i = 0; i < 20; ++i)
{
try
{
Thread.sleep((long) Math.random() * 1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("Hello: " + i);
}
}
public static synchronized void execute2()
{
for (int i = 0; i < 20; ++i)
{
try
{
Thread.sleep((long) Math.random() * 1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("World: " + i);
}
}
}
static class Thread1 extends Thread
{
private Example example;
public Thread1(Example example)
{
this.example = example;
}
@Override
public void run()
{
example.execute();
}
}
static class Thread2 extends Thread
{
private Example example;
public Thread2(Example example)
{
this.example = example;
}
@Override
public void run()
{
example.execute2();
}
}
不加静态方法方法：
当某个synchronized方法是static的，那么当线程访问该方法时，他锁的并不是synchronized方法所在的对象，而是synchronized方法所在类的对应的class对象（java中，一个类无论有多少对象，这些对象会对应唯一的class对象，因此当线程分别访问一个类的两个对象的的两个static synchronized方法时，他们的执行顺序也是有顺序的，也就是说一个线程先去执行，执行完释放锁，另一个线程再去执行）
synchronized代码块
synchronized（object） {
}
表示的是在执行过程中会将object对象上锁（这个对象可以使任意类的对象，也可以使用this），可以自行规定上锁对象
public class test {
public static void main(String[] args) {
Example example = new Example();
Thread t1 = new Thread1(example);
Thread t2 = new Thread2(example);
t1.start();
t2.start();
}
}
class Example {
private Object object = new Object();
public void execute() {
System.out.println("我开始了");
synchronized (object) {
for (int i = 0; i < 20; ++i) {
try {
Thread.sleep((long) Math.random() * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Hello: " + i);
}
}
}
public void execute2() {
System.out.println("我也开始了");
synchronized (object) {
for (int i = 0; i < 20; ++i) {
try {
Thread.sleep((long) Math.random() * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("World: " + i);
}
}
}
}
class Thread1 extends Thread {
private Example example;
public Thread1(Example example) {
this.example = example;
}
@Override
public void run() {
example.execute();
}
}
class Thread2 extends Thread {
private Example example;
public Thread2(Example example) {
this.example = example;
}
@Override
public void run() {
example.execute2();
}
}
可以看到除了synchronized代码块里的方法，其他是不会同步执行的。
synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行synchronized方法。
synchronized块则是细粒度的并发控制，只会将块中的代码同步，方法内的其他代码是可以被多个线程同时访问到的