java多线程编程核心技术1-Thread基础知识

一。Java多线程技能：
1. 一个进程正在运行时至少会有一个线程正在运行，main方法的线程是由JVM创建的，通过jps能检测到。
2. 使用多线程技术时，代码的运行结果与代码的执行顺序或调用顺序是无关的。
3. new Thread（Runnable target）不只可以传入Runnable接口的对象，还可以传入另一个Thread类的对象，完全可以将一个Thread对象中的run（）
   方法交由其他的线程进行调用。
4. 在main方法中创建线程并调用其start()，线程的构造方法是在main线程里执行的，run方法在对应的线程里执行，但是如果直接调用线程的run方法，则其也是在main线程里执行的。
5. isAlive()方法：判断当前的线程是否处于活动状态，注意：将线程对象以构造参数的方式传递给Thread对象进行start()时，this指的时线程对象， Thread.currentThread()或this.Thread.currentThread()指的时Thread对象，Thread对象时存活的（isAlive()）
6. Thread.sleep()方法：让当前线程休眠，如果在main方法里通过调用线程类的run方法执行线程，则虽然Thread.sleep()在run方法里，休眠的仍然是main线程（可通过打印this.currentThread().getName()印证）   
7. getId()方法的唯一作用是取得线程的唯一标识。



二。线程的中断：

1.通过interrupt()中断：
1. thread.interrupt(): 中断thread对象所代表的线程。
2. Thread.currentThread().interrupt(): 中断当前线程。
3. this.interrupted()/Thread.interrupted(): 测试当前线程是否已经中断,如果已被设置中断标记，调用过一次后会清除此标记，导致再次调用没有。
4. this.isInterrupted()/Thread.isInterrupted():测试线程是否已经中断,调用后不清除中断标记。


2.通过异常法中断：

    1.通过在线程的run方法中的for循环里判断线程是否停止状态（this.interrupted()）。

	public class MyThread1 extends Thread {
		@Override
		public void run() {
			super.run();
			for (int i = 0; i < 500000; i++) {
				if (this.interrupted()) {
					System.out.println("已经是停止状态了!我要退出了!");
					break;
				}
				System.out.println("i=" + (i + 1));
			}
			System.out.println("如果我会for循环又会继续运行......");
		}
	}

2.为了避免中断后for下面的语句仍然运行，需要中断时抛出中断异常并处理中断。

	public class MyThread1 extends Thread {
		@Override
		public void run() {
			super.run();
			try {
				for (int i = 0; i < 500000; i++) {
					if (this.interrupted()) {
						System.out.println("已经是停止状态了!我要退出了!");
						throw new InterruptedException();
					}
					System.out.println("i=" + (i + 1));
				}
				System.out.println("如果我会for循环又会继续运行......");
			} catch (InterruptedException e) {
				System.out.println("进MyThread.java类run方法中的catch了！");
				e.printStackTrace();
			}
		}
	}

3.在睡眠中停止线程：
1.先sleep再interrupt：如果在sleep状态下停止某一线程，会进入catch语句并且清除停止状态值，使之变成false，sleep之后的程序不会执行。
2.先interrupt再sleep：如果在sleep之前还有程序如for循环，调用中断后并不会影响for循环的执行，等执行到sleep时才进入catch语句并且清除停止状态值，使之变成false。

	public class MyThread1 extends Thread {
		@Override
		public void run() {
			super.run();
			try {
				// 调用此线程的interrupt方法是，for循环会正常执行完毕
				for (int i = 0; i < 500000; i++) {
					System.out.println("i=" + (i + 1));
				}
				System.out.println("run begin");
				Thread.sleep(200000);
				System.out.println("run end");
			} catch (InterruptedException e) {
				System.out.println("先停止，再遇到了sleep!进入catch!");
				e.printStackTrace();
			}
		}
	}

4.暴力停止线程：
  1.thread.stop():是一个depreated方法，线程被暴力停止（stop）运行后图标呈灰色，调用stop方法时会抛出ThreadDeath异常，通常不需要显示的捕捉
  2.缺点：1.强制停止线程可能使一些请理性的工作得不到完成。
        2.对锁定的对象进行了“解锁”，导致数据得不到同步的处理，出现数据不一致的问题。
  


5.使用return停止线程：
  1.将方法interrupt()与return结合使用也能实现停止线程的效果。

	public class MyThread1 extends Thread {
		@Override
		public void run() {
			while (true) {
				if (this.isInterrupted()) {
					System.out.println("停止了!");
					return;
				}
				System.out.println("timer=" + System.currentTimeMillis());
			}
		}
	}

三。暂停线程：
1. 使用suspend()方法暂停线程，使用resume()方法恢复线程的执行。
   缺点1-独占：
   1.极易造成公共对象的独占，使得其他线程无法访问公共同步对象。
           如一个线程进入了一个公共对象的同步方法内suspend()了后，由于始终占据锁不放，所以其他线程无法进入这个公共对象的此同步方法内。

	public class SynchronizedObject {
		synchronized public void printString() {
			System.out.println("begin");
			if (Thread.currentThread().getName().equals("a")) {
				System.out.println("a线程永远 suspend了！");
				Thread.currentThread().suspend();
			}
			System.out.println("end");
		}
	}

2.另一种独占情况，当把run方法中的打印语句放开后，main方法里的打印语句不会执行，因为打印方法prinln内部实现是同步的代码块
 分为打印和换行两步，当程序运行到代码块内部suspend时，打印语句的锁不会释放，导致main方法里的打印语句不能执行。

	public class MyThread extends Thread {
		private long i = 0;

		@Override
		public void run() {
			while (true) {
				i++;
				// System.out.println(i);
			}
		}
	}

	public class Run {
		public static void main(String[] args) {
			try {
				MyThread thread = new MyThread();
				thread.start();
				Thread.sleep(1000);
				thread.suspend();
				System.out.println("main end!");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

缺点2-不同步：
1.容易出现因为线程的暂停而导致数据不同步的情况。
 即如果设置共享对象多个值中间suspend了线程，导致此对象的值只被设置了一部分，从而其他线程使用该对象时出现了值不一致的情况。




四.yield方法：
  作用：放弃当前的CPU资源，将它让给其他的任务，但放弃的时间不确定，有可能刚刚放弃，马上又获得CPU的时间片。
  如下示例：for循环中每次都yield一次，等待再次获取，总的执行时间将呈几何倍增加。  

	public class MyThread1 extends Thread {
		@Override
		public void run() {
			long beginTime = System.currentTimeMillis();
			int count = 0;
			for (int i = 0; i < 50000000; i++) {
				// Thread.yield();
				count = count + (i + 1);
			}
			long endTime = System.currentTimeMillis();
			System.out.println("用时：" + (endTime - beginTime) + "毫秒！");
		}


	}

五。线程的优先级：
1. setPriority():用于设置线程的优先级，优先级较高的线程获得的CPU资源较多，设置优先级有助于帮“线程规划器”确定下一次选择哪一个线程来优先执行。
   线程优先级分为1~10这10个等级，不在此范围内的优先级会抛出异常，常用1,5,10标识低、中、高优先级。
2.线程优先级的继承特性：A线程启动B线程，则B线程的优先级与A是一样的。
3.线程的优先级具有规则性：
  1.优先级高的大部分情况下是先执行完的，尽管它可能启动时间可能晚于其他低优先级的线程。   
  2.“随机性”，优先级较高的线程不一定每一次都先执行完。
4.结论：不要把线程的优先级与运行结果的顺序作为衡量的标准，优先级较高的线程并不一定每一次都先执行完run()方法中的任务。



六。守护线程：
1. 当进程中没有非守护线程时，则守护线程自动销毁。 Daemon为其他线程的运行提供便利服务，守护线程最经典的应用就是GC垃圾回收器。
2. 通过thread.setDaemon(true)来设置一个线程为守护线程。
   

	public class MyThread1 extends Thread {
		private int i = 0;

		@Override
		public void run() {
			try {
				while (true) {
					i++;
					System.out.println("i=" + (i));
					Thread.sleep(100);
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public class MyTest2 {
		public static void main(String[] args) throws InterruptedException {
			try {
				MyThread1 thread = new MyThread1();
				thread.setDaemon(true);
				thread.start();
				Thread.sleep(5000);
				System.out.println("我离开thread对象也不再打印了，也就是停止了！");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}