java多线程及synchronized

通常我们所说的程序它只是一个静态的概念，而进程是其动态性的体现，而进程又可以拥有一个或多个线程，线程是程序中单独顺序的控制流，线程本身不能运行，它只能用于程序中
一个类要想成为线程类有两种方法，第一是继承Thread类并重写其run方法，第二种是实现Runnable接口，也要去重写其run方法说到线程肯定要说道线程同步，下面是我对线程同步的理解
1.java中的对象都有一个锁(lock)或者叫做监视器(monitor),当访问某个对象的synchronized方法时，表示将该对象上锁,此时其它任何线程都不能访问这个上了锁的方法了直到之前线程执行完(或者抛出了异常)，那么将该对象的锁释放掉，其他线程才能再去访问这个方法

2.如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的

3.如果某个synchronized方法是static的，那么当线程访问该方法时，它锁住的并不是synchronized方法所在的对象，而是synchronized方法所在的对象所对应的Class对象，因为java中无论一个类有多少个对象，这些对象对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，它们的执行顺序也是同步的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始执行

package com.lamp.test;

public class SourceTest {
	public static void main(String[] args) {
		Source source = new Source();

		Thread t1 = new MyThread(source);

		source = new Source();
		Thread t2 = new MyThread2(source);
		t1.start();
		t2.start();
	}
}

class Source {
	public static synchronized void execute(){
		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("hello" + i);
		}
	}

	public static synchronized void execute2(){

		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("world" + i);
		}
	}
}

class MyThread extends Thread{

	private Source source;

	public MyThread(Source source){
		this.source = source;
	}

	@Override
	public void run() {
		source.execute();
	}

}

class MyThread2 extends Thread{

	private Source source;

	public MyThread2(Source source){
		this.source = source;
	}

	@Override
	public void run() {
		source.execute2();
	}

}

4.synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行该方法，synchronized块则是一种细粒度的并发控制，只会将块中的代码同步，位于方法内，synchronized块外的代码是可以被其他线程访问到的

package com.lamp.test;

public class SourceTest2 {
	public static void main(String[] args) {
		Source2 source = new Source2();

		Thread t1 = new MyThread3(source);

		Thread t2 = new MyThread4(source);
		t1.start();
		t2.start();
	}
}

class Source2 {
	private Object obj = new Object();

	public void execute() {
		synchronized (obj) {
			for (int i = 0; i < 10; i++) {
				System.out.println("hello" + i);
			}
		}

	}

	public void execute2() {

		synchronized (obj) {
			for (int i = 0; i < 10; i++) {
				System.out.println("world" + i);
			}
		}

	}
}

class MyThread3 extends Thread {

	private Source2 source;

	public MyThread3(Source2 source2) {
		this.source = source2;
	}

	@Override
	public void run() {
		source.execute();
	}

}

class MyThread4 extends Thread {

	private Source2 source;

	public MyThread4(Source2 source) {
		this.source = source;
	}

	@Override
	public void run() {
		source.execute2();
	}

}

在实践中是将方法同步还是将代码块同步，这就需要从多方面考虑了