Synchronized的同步代码块，同步方法！and守护线程？

守护线程

package com.laoluo.demo1;
//线程大致分为 用户线程  守护线程
public class Match1 {
	public static void main(String[] args) throws InterruptedException {
		Runner r=new Runner();
		r.setName("守护线程池");
		//把自定义的用户设置为守护线程
//		r.setDaemon(true);//守护线程=true
		
		r.start();
		for (int i = 0; i <10; i++) {
			
				Thread.sleep(100L);
		
			System.out.println(Thread.currentThread().getName()+":"+i);	
		}	
	}
}
	class Runner extends Thread{
		@Override
		public void run() {
			for (; ;) {
				try {
					Thread.sleep(100L);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());		
			}	
	    }

	}

r.setDaemon(true);//守护线程=true 守护线程池是死循环！！
当setDaemon(true)的时候！ 循环结束！！！！

守护线程池
main:0
守护线程池
main:1
守护线程池
main:2
守护线程池
main:3
守护线程池
main:4
守护线程池
main:5
守护线程池
main:6
守护线程池
main:7
守护线程池
main:8
main:9
守护线程池
守护线程池
守护线程池
守护线程池
守护线程池
守护线程池
守护线程池
守护线程池
守护线程池
守护线程池
守护线程池
守护线程池
......守护线程是死循环

Match2

package com.laoluo.demo2;

public class Match2 {
	
	public static void main(String[] args) throws InterruptedException {
		Runner r=new Runner();
		r.setName("小森");
		r.start();
		for (int i = 0; i < 10; i++) {
			Thread.sleep(100L);
			if (i==5) {//当主线程执行到5的时候把用户线程 泰森加进来！	  插队先执行完！
				r.join();
			}
		//	Thread.yield();//线程的礼让

			System.out.println(Thread.currentThread().getName());
		}	

//		r.stop();
//判断线程的是否活
//		System.out.println(r.isAlive());
//				
	}
}
class Runner extends Thread{
	@Override
	public void run() {
		
	   for (int i = 0; i < 10; i++) {
		   try {
			Thread.sleep(100L);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	   
		System.out.println(Thread.currentThread().getName() );
	   }
    }
  }

r.isAlive()方法 判断线程死活 true为死！反则活

// Thread.yield();//线程的礼让 (但是如果礼让的对方不执行!!那我自己继续执行！)
防止cpu压力过大！–对数据类型重新操作

线程交替运行，当主线程执行到5的时候把用户线程 泰森加进来！ 插队先执行完！
if (i==5) {当主线程执行到5的时候把用户线程 泰森加进来！ 插队先执行完！
r.join();
}

main
小森
main
小森
main
小森
main
小森
main
小森
小森
小森
小森
小森
小森
main
main
main
main
main

Match3

操作同步代码块

synchronized---ta是由cpu在数据上面帮你加了一把锁   
操作同步代码块 同步方法
       又叫自动添加锁,自动释放锁
synchronized也叫互斥锁，如果你在这里面放了对象  二个new Object   
synchronized( new Object) new不同对象的地址不同？
二个不相关的锁！！所以他们就没有了互斥性 ，数据就锁不住！！！

没有上锁之前的部分数据！！你会发现很乱！！

冬
寒霜寒霜暑暑假
假
寒霜暑假
春夏秋冬

加锁以后
被修饰以后 就是同步了！！ 执行完内部以后才能出来 不能中途退出
创建 Object obj=new Object();
obj是监听对象, 都也是操作的是 同一把锁！----在内部
synchronized(obj) {}
锁住的时候，正常输出！！

synchronized(this) {}如果里面是this ，就是当前锁！当前对象的锁，就一个对象!

synchronized(ClentTh.class) {}如果里面是当前类 ，就是当前类的锁！也能正确锁住，输出(锁类 ，整个类就一把锁！)

寒霜暑假
春夏秋冬
寒霜暑假
春夏秋冬

加锁以后
如果synchronized里 重新new Object 二个new Object 就是二个对象 二把锁了！！就不能互斥了！
synchronized(new Object) 数据又乱了！

synchronized(new Object（）) {
System.out.print("寒");
System.out.print("霜");
System.out.print("暑");
System.out.print("假");
}
	synchronized(new Object（）) { 
		System.out.print("春");
		System.out.print("夏");
		System.out.print("秋");
		System.out.print("冬");
		System.out.println();
		}
寒霜暑假
寒春霜暑假
夏秋冬
寒霜暑假

package com.laoluo.demo3;

import java.util.Random;

//SyncSample
public class Match3 {
	public static void main(String[] args) {
		 ClentTh ch=new ClentTh();
		 for (int i = 0; i < 100; i++) {
		 new Thread(){	
			int i=new Random().nextInt(2);	
			@Override
			public void run() {
				if (i % 2 == 0) {
					ch.first();
				}
				else {
					ch.last();
				}
			}
		}.start();		
	}
	}
}
//class A extends Thread{  此创建跟上面 Thread一样的--
//   @Override
//public void run() {
//	// TODO Auto-generated method stub
//	super.run();
//}
//}
class  ClentTh{
	Object obj=new Object();
	//synchronized---ta是由cpu在数据上面帮你加了一把锁   
	//同步代码块 同步方法
	//自动添加锁,自动释放锁
	//synchronized也互斥锁，如果你在这里面放了对象  new Object    synchronized( new Object) new不同对象的地址不同？
	//二个不相关的锁！！所以他们就没有了互斥性 ，数据就锁不住！！！
	public 	 void first () {
		
		//被修饰以后 就是同步了！！  执行完内部以后才能出来   不能中途退出
		synchronized( obj) {  //obj监听对象,  我也操作的是 同一把锁！----在内部+1+2+3   -1-2-3的操作
		System.out.print("春");
		System.out.print("夏");
		System.out.print("秋");
		System.out.print("冬");
		System.out.println();
		}
	}	
	
	public void last() {
		synchronized( obj) {
		System.out.print("寒");
		System.out.print("霜");
		System.out.print("暑");
		System.out.print("假");
		System.out.println();
		
		}
	}
	
}

操作同步方法！锁在方法上！ 不能像代码块控制

public synchronized	 void first () {
		System.out.print("春");
		System.out.print("夏");
		System.out.print("秋");
		System.out.print("冬");
		System.out.println();
	}
	public synchronized void last() {
		
		System.out.print("寒");
		System.out.print("霜");
		System.out.print("暑");
		System.out.print("假");
		System.out.println();
		}
}

输出锁住！

春夏秋冬
春夏秋冬
寒霜暑假
春夏秋冬

总结！！！

静态方法就是锁类！！