多线程之同步与锁

           这一篇主要是为了系统的学习下java多线程，留以笔记，以作参考。

         接口中有一个叫做Runnable，里面只有一个需要实现的方法run（）.

有一个实现了Runnable的线程类，称为Thread。

最简单的新建线程就是继承Thread,通过复写run方法来实现自己的功能，然后通过调用他的start来新建线程，会自动调用其run方法来运行。

       

	public class MyThread extends Thread{
		//其它属性
		private String name;
		//其它方法
		public MyThread(String name) {
			this.name=name;
		}
		private void show() {
			System.out.println(this.name);
		}
		@Override
		public void run() {
			/**需要新建线程完成的工作**/
			show();
		}
	}
}

可以通过new MyThread("sss").start()来开始线程。

另外一种简单方法就是使用Thread(Runnable target).这种方式很简单，使用匿名内部类方式，可以使线程的建立变得极其简单明了

		Thread th=new Thread(new Runnable() {
			@Override
			public void run() {
				//线程任务
				System.out.println("ss");
			}
		});
		th.start();

复合方式，这个我没使用过，两个都进行了重写

		Thread th=new Thread(new Runnable() {
			@Override
			public void run() {
				//线程任务
				System.out.println("Runnable");
			}
		}){
			@Override
			public void run() {
				//线程任务
				System.out.println("Thread");
		}};
		th.start();

原因是虽然传递了Runnable,但是，thread的start()其实是运行的自身的run(),方法，如果我们重写了此方法则调用复写的run。

而runnable在thread中只是一个成员变量target，他的调用还是依赖于Thread的默认人run方法调用

    public void run() {
        if (target != null) {
            target.run();
        }
    }

当使用了 多线程线程后 ，就不可避免的会遇到资源共享的问题。
第一种是使用同步， synchronized，这种方方式可以写在函数名中当修饰符，也可以写在函数内，前者使用this作为监视器，后者可以指定监视器

这里就不得说说监视器了 ，我认为监视器就是以某物作为参照，监视其状态。比如上面的synchronized，在函数中是以对象也就是this为参照物，而在函数中是以指定的object为参照物。

       当一个线程运行到同步代码入口处时就会查验监视器，根据监视器状态来确定是否进入。

        每当有线程进入函数和离开时都会修改监视器的状态。

           

       另外一种方式是使用lock。这种方式比较灵活，可以根据需要选择使用，互斥锁，读写锁。但是要求手动获取和释放。

流程也很简单在需要保护的代码开始处获取锁，在离开时释放锁，但一般在finally里面释放，避免出现异常后不能正确释放导致死锁。

class X {
   private final ReentrantLock lock = new ReentrantLock();

   public void m() { 
     lock.lock();  //获取锁
     try {
       //需要保护代码
     } finally {
       lock.unlock()//释放锁
     }
   }
 }

         以上的目的都是为了保证资源在被共享时，不会被多个线程同时修改和读取（特殊如读写锁外），从而保证了资源的正确性。