java-多线程

最新推荐文章于 2024-03-10 23:38:03 发布

kuangpeng1956

最新推荐文章于 2024-03-10 23:38:03 发布

阅读量154

点赞数

分类专栏： java知识总结文章标签： java 多线程 Thread

本文链接：https://blog.csdn.net/kuangpeng1956/article/details/84036660

版权

java知识总结专栏收录该内容

12 篇文章 1 订阅

订阅专栏

多线程

多线程中的基本概念

进程：
（1）概念：一个程序的执行。
（2）特点：
      1、每个进程都有独立的代码和数据空间（进程上下文）。
      2、进程间的切换会有较大的开销。
      3、一个进程包含1–n个线程。（进程是资源分配的最小单位）
（3）多进程是指操作系统能同时运行多个任务（程序）。
线程：
（1）概念：程序中单个顺序的流的控制；
（2）特点：
      1、同一类线程共享代码和数据空间，
      2、每个线程有独立的运行栈和程序计数器(PC)，
      3、线程切换开销小。（线程是cpu调度的最小单位）
（3）多线程是指在同一程序中有多个顺序流在执行。
多线程的优点
（1）资源利用率更好
（2）程序设计在某些情况下更简单
（3）程序响应更快
多线程的缺点
（1）设计更复杂
（2）上下文切换的开销
（3）增加资源消耗
并行和并发
（1）并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
（2）并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。

创建并运行线程

Java 线程类也是一个 object 类，它的实例都继承自 java.lang.Thread 或其子类。可以用如下方式用 java 中创建并运行一个线程：

Thread thread=new Thread();//创建一个线程
	         thread.start();//运行该线程

（1）由于我们没有为该线程写运行代码，所以调用完就终止了。
（2）start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。

编写需要的多线程代码一般有两种方法
（1）将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。
例如：判断一个数是不是素数

package ThreadDemo;

class myThread extends Thread{
      private int num;
      public myThread(int num){
    	  this.num =num; 
      }
		public void run() {	 
			boolean isPrime = true;
		    	   for(int i =2;i<=Math.sqrt(num);i++){
		    		   if(num%i==0){
		    			   isPrime =false;
		    			   break;
		    		   }  
		    	   }
		    	   if(isPrime){
		    		   System.out.println("this is  a prime");
		    	   }else{
		    		   System.out.println("this is not a prime");
		    	   }
	
		}
}
public class ThreadDemo {
	  public static void main(String[] args) {
	         Thread thread=new myThread(3);
	        thread.start();
	    }
}

（2）声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
例如：判断一个数是否为素数

package ThreadDemo;

class myThread implements Runnable{
      private int num;
      public myThread(int num){
    	  this.num =num; 
      }
		public void run() {	 
			boolean isPrime = true;
		    	   for(int i =2;i<=Math.sqrt(num);i++){
		    		   if(num%i==0){
		    			   isPrime =false;
		    			   break;
		    		   }  
		    	   }
		    	   if(isPrime){
		    		   System.out.println("this is  a prime");
		    	   }else{
		    		   System.out.println("this is not a prime");
		    	   }
	
		}
}
public class ThreadDemo {
	  public static void main(String[] args) {
	         Thread thread =new Thread(new myThread(4));
	         //将实现Runable的类的实例当做参数传进去
	        thread.start();
	    }
}

实质上Thread类也实现了Runable接口

一般来说，使用Runable接口更为普遍一些，主要原因是：
（1）如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享，可以避免java中的单继承的限制。
（2）适合多个相同的程序代码的线程去处理同一个资源
（3）线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类
（4）增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

线程的生命周期

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();
就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；
运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
（1）等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
（2）同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
（3）其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程调度

调整线程的优先级
1、线程的调度模型分为: 分时调度模型和抢占式调度模型,Java使用抢占式调度模型
（1）分时调度模型: 所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片
（2）抢占式调度模型: 优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的CPU时间片相对多一些.
2、Java线程的优先级用整数表示，取值范围是1~10，这10个线程优先级，与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用Thread类的三个静态常量作为优先级，这样能保证同样的优先级采用了同样的调度方式。Thread类有以下三个静态常量。

			static int MAX_PRIORITY
			          线程可以具有的最高优先级，取值为10。
			static int MIN_PRIORITY
			          线程可以具有的最低优先级，取值为1。
			static int NORM_PRIORITY
			          分配给线程的默认优先级，取值为5。

3、每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。
4、线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。

线程睡眠
Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。
线程调度
线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。
线程让步：
Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。
线程加入：
join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。
线程唤醒：
Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。

常用方法介绍

下面所有的实例代码均是三个线程，t1,t2,main。每个线程都是输出0-4的整数，在此基础上添加常用的函数，观察输出结果。
其中线程代码为

class myThread extends Thread{
		public void run() {	 
			System.out.println(getName()+"运行开始");
			for(int i=0;i<5;i++){
				System.out.println(getName()+" "+ i);
			}
	   System.out.println(getName()+"运行结束");
		}
}

常用方法

1、public static void sleep(long millis) throws InterruptedException
//在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器
//和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

public class ThreadDemo {
	  public static void main(String[] args) {
		  System.out.println(Thread.currentThread().getName()+"开始运行了");
	
		  Thread t1=new myThread();
	         t1.setName("t1");
	        t1.start();
	        Thread t2 =new myThread();
	        t2.setName("t2");
	        t2.start();
	       try {
			t1.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	 	  for(int i=0;i<5;i++){
	        	System.out.println(Thread.currentThread().getName()+" "+i);
	        }
	        System.out.println(Thread.currentThread().getName()+"运行结束了");
	    }
}

main开始运行了
t1运行开始
t2运行开始
t1 0
t2 0
t1 1
t2 1
t1 2
t2 2
t1 3
t2 3
t1 4
t2 4
t1运行结束
t2运行结束
main 0
main 1
main 2
main 3
main 4
main运行结束了

（1）sleep是让当前线程休眠，所以即使调用的t1.sleep(100)，但由于在main函数中调用，所以是让主线程休眠了100ms。
（2）start()方法的调用后并不一定立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。
（3）运行结果是 main生成并启动了t1和t2线程，main线程休眠100ms，t1和t2交替运行，100ms之后main线程开始运行。

 2、void join() 
          等待该线程终止。 
 void join(long millis) 
          等待该线程终止的时间最长为 millis 毫秒。 
 void join(long millis, int nanos) 
          等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

为什么要使用join方法？
在很多情况下，主线程生成并启动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

public class ThreadDemo {
	  public static void main(String[] args) {
		  System.out.println(Thread.currentThread().getName()+"开始运行了");
	         Thread t1=new myThread();
	         t1.setName("t1");
	        t1.start();//启动了t1子线程
	        Thread t2 =new myThread();
	        t2.setName("t2");
	        t2.start();//启动了t2子线程
	       try {
			t1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	        for(int i=0;i<5;i++){
	        	System.out.println(Thread.currentThread().getName()+" "+i);
	        }
	        System.out.println("运行结束了");
	    }
}

main开始运行了
t1运行开始
t1 0
t1 1
t2运行开始
t1 2
t2 0
t1 3
t2 1
t1 4
t2 2
t1运行结束
t2 3
t2 4
t2运行结束
main 0
main 1
main 2
main 3
main 4
运行结束了

运行结果是：
main线程生成并启动了t1和t2线程，main线程等待t1运行结束之后才运行，所以开始时，t1和t2交替运行，当t1结束时，main开始运行，如果t2还没结束，main和t2交替运行，如果t2已结束，运行main线程直至结束。

3、public static void yield()
		暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

package ThreadDemo;

class myThread extends Thread{
		public void run() {	 
			System.out.println(getName()+"运行开始");
			for(int i=0;i<5;i++){
				System.out.println(getName()+" "+ i);
				if(i==3){
					System.out.println(Thread.currentThread().getName()+"变为可运行态");
					Thread.currentThread().yield();
				}
				
			}
	   System.out.println(getName()+"运行结束");
		}
}
public class ThreadDemo {
	  public static void main(String[] args) {
		  System.out.println(Thread.currentThread().getName()+"开始运行了");
	
		  Thread t1=new myThread();
	         t1.setName("t1");
	        t1.start();
	        Thread t2 =new myThread();
	        t2.setName("t2");
	        t2.start();
	     
	 	  for(int i=0;i<5;i++){
	        	System.out.println(Thread.currentThread().getName()+" "+i);
	        }
	        System.out.println(Thread.currentThread().getName()+"运行结束了");
	    }
}

main开始运行了
main 0
main 1
main 2
main 3
main 4
main运行结束了
t1运行开始
t1 0
t1 1
t1 2
t1 3
t1变为可运行态
t2运行开始
t2 0
t2 1
t2 2
t2 3
t2变为可运行态
t1 4
t1运行结束
t2 4
t2运行结束

运行结果：
当t1线程和t2线程运行到等于3时，变为可运行态，但是接下来仍然有可能重新被cpu调入接着运行。也有可能cpu调用其他线程。

sleep()和yield()的区别
（1）sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
（2）sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
（3）sleep 方法允许较低优先级的线程获得运行机会，但 yield() 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

4、public final void setPriority(int newPriority)
		更改线程的优先级。 
		MIN_PRIORITY = 1
  　   NORM_PRIORITY = 5
        MAX_PRIORITY = 10

public class ThreadDemo {
	  public static void main(String[] args) {
		  System.out.println(Thread.currentThread().getName()+"开始运行了");
	
		  Thread t1=new myThread();
	         t1.setName("t1");
	        t1.start();
	        t1.setPriority(Thread.MIN_PRIORITY);
	        Thread t2 =new myThread();
	        t2.setName("t2");
	        t2.start();
	       t2.setPriority(Thread.MAX_PRIORITY);
	 	  for(int i=0;i<5;i++){
	        	System.out.println(Thread.currentThread().getName()+" "+i);
	        }
	        System.out.println(Thread.currentThread().getName()+"运行结束了");
	    }
}

main开始运行了
main 0
t2运行开始
main 1
t2 0
main 2
t2 1
main 3
t2 2
main 4
t2 3
main运行结束了
t2 4
t2运行结束
t1运行开始
t1 0
t1 1
t1 2
t1 3
t1 4
t1运行结束

优先级高的一定比优先级低的先运行吗？
其实，即使设置了线程的优先级，一样无法确保这个线程一定先执行，因为它有很大的随机性。它并无法控制执行哪个线程，因为线程的执行，是抢占资源后才能执行的操作，而抢点资源时，最多是给于线程优先级较高的线程一点机会而已，能不能抓住可是不一定的。。
说到底就一句话：线程优化级较高的线程不一定先执行。

5、public void interrupt()
//不要以为它是中断某个线程！它只是给线程发送一个中断信号，让线程在无限等待时
（如死锁时）能抛出异常，从而结束线程，但是如果你吃掉了这个异常，那么这个线程
还是不会中断的！

6、Obj.wait()
   Obj.notify()
wait()和notify()方法是继承自Object。是java中所有类都有的方法，说明java从最开始设计
时，便考虑了多线程。

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){…}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。
Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。
例子：
三个线程打印ABC十次，要求A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。

package ThreadDemo;

import org.omg.CORBA.PRIVATE_MEMBER;

public class waitDemo implements Runnable {
	 private String name;
	 private Object pre;
	 private Object self;
	  public waitDemo(String name,Object pre,Object self){
		     this.name =name ;
		     this.pre = pre;
		     this.self = self;
	  }
	  
	    public static void main(String[] args) throws Exception {   
	    	Object a=new Object();
	    	Object b=new Object();
	    	Object c=new Object();
	    	waitDemo paDemo =new waitDemo("a", c, a)     ;
	    	waitDemo pbDemo =new waitDemo("b", a, b)     ;
	    	waitDemo pcDemo =new waitDemo("c", b, c)     ;
	    	new Thread(paDemo).start();
	    	Thread.sleep(100);
	    	new Thread(pbDemo).start();
	    	Thread.sleep(100);
	    	new Thread(pcDemo).start();
	    	Thread.sleep(100);
	    
	        }
		@Override
		public void run() {
		     	int count =10;
		     	while(count>0){
		     	      synchronized (pre) {
							synchronized (self) {
								System.out.print(name);
								count--;
							 self.notify(); 
							}
							try {
								pre.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}
		     	}  
		}   
}

运行结果：abcabcabcabcabcabcabcabcabcabc
运行结果分析：
先来解释一下其整体思路，从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是pre，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有pre锁，也就前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印，之后首先调用self.notify()释放自身对象锁，唤醒下一个等待线程，再调用pre.wait()释放pre对象锁，终止当前线程，等待循环结束后再次被唤醒。运行上述代码，可以发现三个线程循环打印ABC，共10次。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A,B,C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序。

wait和sleep区别
共同点：
（1）他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
（2）wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。
如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。

不同点：
（1） Thread类的方法：sleep(),yield()等
Object的方法：wait()和notify()等
（2）每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
（3）sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
（4）wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
所以sleep()和wait()方法的最大区别是：
　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；
　　　　而wait()睡眠时，释放对象锁。
　　但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

sleep（）方法
      sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
      sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
      在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。
wait（）方法
      wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
      wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
      wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。

常见线程名词解释

主线程：JVM调用程序main()所产生的线程。
当前线程：这个是容易混淆的概念。一般指通过Thread.currentThread()来获取的进程。
后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束
前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

守护线程实例

package ThreadDemo;

public class DaemonDemo implements Runnable{

	public static void main(String[] args) {
		 System.out.println("main开始运行");
		 DaemonDemo daemonDemo =new DaemonDemo();
		 Thread t1 =new Thread(daemonDemo);
		 t1.setName("t1");
		 t1.setDaemon(true);//一定在start()之前。
		 t1.start();
		 for(int i=0;i<10;i++){
			  System.out.println(Thread.currentThread().getName()+" "+i);
		 }
		 System.out.println("main已经结束");
	}

	@Override
	public void run() {
		  for(int i=0;i<30;i++){
			  System.out.println(Thread.currentThread().getName()+" "+i);
		  }
		
	}
}

main开始运行
main 0
main 1
main 2
t1 0
t1 1
main 3
t1 2
main 4
t1 3
main 5
t1 4
main 6
t1 5
main 7
t1 6
main 8
t1 7
main 9
t1 8
main已经结束
t1 9
t1 10
t1 11
t1 12
t1 13
t1 14
t1 15
t1 16
t1 17
t1 18
t1 19
t1 20
t1 21

从运行结果可以看出，守护线程并没有完全执行，当没有正在执行的用户线程时，守护线程退出。

线程的同步

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。
修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象。
修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象。
修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；
无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
每个对象只有一个锁（lock）与之相关联。
现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

接着来讨论synchronized用到不同地方对代码产生的影响：
1、synchronized当作函数修饰符：

Public synchronized void methodAAA()
{
//….
}

在这种情况下，锁定的是调用这个方法的对象，当一个对象在不同的线程中调用这个方法时会发生互斥，但是同一个类的不同的对象在不同的线程中调用并不会互相影响。
它等同于下面这种写法

public void methodAAA()
{
synchronized (this)      //  (1)
{
       //…..
}
}

在这里，this指代调用这个方法的当前对象，如P1。可见同步方法实质是将synchronized作用于object reference。那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2对象而言，P1这个锁与它毫不相干。

2、synchronized当作同步块

 public void method3(SomeObject so)
    {
                     synchronized(so)
				{
    						   //…..
					}
	}

这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

class Foo implements Runnable
{
       private byte[] lock = new byte[0];  // 特殊的instance变量
    Public void methodA()
{
       synchronized(lock) { //… }
}
//…..
}

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。
3、将synchronized作用于static 函数，示例代码如下：

Class Foo
{
public synchronized static void methodAAA()   // 同步的static 函数
{
//….
}
public void methodBBB()
{
       synchronized(Foo.class)   //  class literal(类名称字面常量)
}
       }

代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。

总结一下：
1、线程同步的目的是为了保护多个线程访问一个资源时对资源的破坏。
2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法
3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
4、对于同步，要时刻清醒在哪个对象上同步，这是关键。
5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。