线程与进程

线程的实现：
一种是通过继承 Thread 类构造线程，另一种是通过实现 Runnable 接口构造线程。
Thread类：
（1）public Thread()
（2）public Thread(Runnable target)
（3）public Thread(String name)
（4）public Thread(ThreadGroup group, Runnable target)
（5）public Thread(ThreadGroup group, String name)
（6）public Thread(ThreadGroup group, Runnable target,String name)
Runnable接口：
注意：
Thread是类，所以继承类要用extends
Runnable 是接口，继承时要用implements
实例：

package test1;

public class 线程与进程 {

	public class ThreadClassOne extends Thread{
		public int i=0;
		public ThreadClassOne(){
			super();
		}
		public void run(){
			for(i=0;i<10;i++){
				if(i%2==1)
					System.out.print(i+" ");
			}
		}
	}
	public class ThreadClassTwo implements Runnable{
		public int i=0;
		private Thread mythread;
		public void run(){
			for(i = 0;i < 11; i ++ ){
				if(i % 2 == 0)
					System.out.print(i + " ");
			}
		}
	}
}

用线程来计算斐波那契：

package test1;

import java.util.Scanner;

public class 线程与进程2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		//请在此添加实现代码
		/********** Begin **********/
		Thread t = new MyThread("子线程",num);
		//常用函数sleep和join
		t.start();
		try{
			t.join();
		}catch(Exception e){
			}
	}
}

class MyThread extends Thread{
	private int num;
	private String name;
	public MyThread(String name,int num){
		this.num=num;
		this.name=name;
	}
	public void run(){
		int[] arr = new int[2];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < num; i++) {
            int tmp = arr[1];
            arr[1] = arr[0] + arr[1];
            arr[0] = tmp;
        }
        System.out.println("子线程计算结果为："+arr[1]);
	}
}

**线程是比进程更小的执行单位。**一个进程在其执行过程中，可以产生多个线程，形成多条执行线索。
为什么要用到线程？
因为我们在同时进行多个任务时，使用的就是多线程！
线程：是指在操作系统内独立执行某个任务的一个单元
进程；是指在操作系统中正在运行的一个应用程序
QQ是是一个进程，如果你在和A朋友语音聊天的同时和B朋友打字聊天，同时还在QQ群下载图片，这三个操作就相当于开启了三个线程。

挂起线程：
（1）sleep()方法 
sleep()方法,可用于让线程沉睡若干毫秒。sleep()的方法原型如下： 
public static void sleep(long millis) throws InterruptedException 
public static void sleep(long millis, int nanos) throws InterruptedException它没有返回值,只接受线程沉睡时间。例如，参数为 1000 时，sleep()方法的执行结果就是让当前线程沉睡 1 秒钟，而 1 秒后，
线程会自动苏醒，并继续执行后续的代码。sleep()方法并非一定能够运行成功，
当线程处在挂起状态时，由于某种原因被打断了，它会抛出一个类型为 InterruptedException 的异常,这个异常没必要向外传递，
用try-catch 语句直接处理即可。
try { 
Thread.sleep((int)(Math.random() *2000)); } 
catch (InterruptedException ex ) 
{ 
System.err.println(ex.toString()); 
} 
（2）yield()方法 
yield() 为静态方法，功能是暂停当前正在执行的线程对象，并执行其他线程。即它会暂停当前的线程，并将其放入可运行队列，而选同优先级的另一线程运行。当然，如果没有相同优先级的可运行线程，yield()将什么也不做，继续让当前线程执行。需要注意的是：sleep()调用会给较低优先级的线程一个运行机会，而 yield()方法只会给相同优先级线程一个执行机会。
（3）interrupt()方法 
一个线程运行时，另一个线程可以调用对应 Thread 对象的 interrupt()方法来中断它。
（4）wait()方法 
wait ()方法是在 Object 类中声明的方法，它使线程进入等待状态，
直至被另外一个线程唤醒。
它与 Object 类中声明的另一个方法 Notify()配对使用，
完成线程通讯与同步。
（5）join()方法 
join()方法的功能是将几个并行的线程合并成单线程执行。join()为非静态方法。
如果某线程（线程 A）只有在另一线程（线程 B）终止时才能继续执行，
则这个线程（线程 A）可以调用另一线程(线程 B)的 join()方法，
将两个线程“联结”在一起，即线程 A 先执行，而后被挂起，线程 B 执行，
直到终止时线程 A 回到可运行状态继续执行。另外，
join()方法可以传入一个最多等待时间的参数，用于控制等待时间。

检查线程：
（1）getName()方法和 setName()方法 
在 Thread 类之中，可以通过 getName()方法取得线程的名称，
通过 setName()方法设置线程的名称。
（2）isAlive()方法 
在程序中也可以通过 isAlive()方法来测试线程是否已经启动而且仍然在启动。
当线程处于新建状态时，线程调用该方法将返回“false”；当线程调用 start 方法，
并占有 CPU资源后，该线程的 run()方法开始运行，在线程的 run()方法结束之前，
即线程未进入死亡状态之前，线程调用 isAlive()方法返回“true”。当线程进入死亡状态后（实体内存已释放），线程仍可调用 isAlive()方法，返回为“false”。 
（3）currentThread()方法 
Java 代码是由某一 Java 线程执行的,Thread 类提供一个静态方法 currentThread()用于获得这一线程，以便进一步控制线程的执行。
该方法的返回值是Thread 的引用，
这个引用所指向的 Thread 类的实例正是“执行当前代码的线程”。 
（4）getPriority()方法 
getPriority()方法用于检查当前线程的优先级。 

结束线程：
(1) stop()方法 
程序中需要强制终止某线程的生命周期时可以使用 stop()方法。
stop（）方法将会使线程由其他状态进入死亡状态。
不推荐使用 stop()方法来强制终止线程，因为它将会导致错误发生。
例如：如果一个线程正在操作共享数据段，操作过程没有完成就被 stop 了的话，
将会导致数据的不完整性。
（2）destroy（）方法 
程序可以使用 destroy（）方法来强制结束线程，但是这个方法在结束线程后，
将不会释放锁，因此也不被推荐使用。
（3）参数控制法 
这里可以用一个指示 run()方法必须退出的标志来停止一个线程。具体步骤如下： 
① 编写一个类继承 Thread 类。 
② 在这个类中增加一个布尔变量，并将其值初始化为 false； 
③ 覆盖 start()方法，首先将布尔变量的值置为 true，
然后调用 super.start()方法。 
④ 提供一个 public 方法 halt()，它将变量置为 false； 
⑤ 在 run()方法中使用类似下例的 while 循环： 
Public void run(){ 
While(布尔参数){ 
线程要执行的代码} 
} 
如果这样一个线程的 halt()方法被调用，就会将布尔参数的值置为假，
从而引run() 方法终止执行，从而结束该线程。

同步方法和同步块：
（1）synchronized 方法 
通 过 在 方 法 声 明 中 加 入 synchronized 关 键 字 
来 声 明 synchronized 方 法。synchronized 方法控制对类成员变量的访问：
每个类实例对应一把锁，每个 synchronized 
方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，
方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，
此后被阻塞的线程方能获得该锁，重新进入可执行状态。不仅是类实例，
 Java 中的每一个类也对应一把锁，用户也可将类的静态成员函数声明 
为 synchronized，以控制其对类的静态成员变量的访问。 
（2）synchronized 块 
通过 synchronized 关键字来声明 synchronized 块。语法如下： 
synchronized(syncObject) { 
//允许访问控制的代码 
} 
synchronized 块的代码必须获得对象 syncObject 的锁方能执行。

线程间的协作：
由于此时其他线程无法进入临界区，所以就需要该线程放弃监控器，
并返回到排队状态等待其他线程交回监控器。
为此，Java 语言中引入了 wait()方法和 notify()方法。
（1）wait()方法 
wait()方法用于使当前线程放弃临界区而处于睡眠状态，
直到有另一线程调用 notify() 方法将它唤醒或睡眠时间已到为止。
（2）notify()方法 
notify()方法用于将处于睡眠状态的某个等待当前对象监控器的线程唤醒。
如果有多个这样的线程，则按照先进先出的原则唤醒第一个线程。
Object 类中还提供了另一个方法notifyAll()，
用于唤醒所有因调用 wait()方法而睡眠的线程。