Java学习系列(十四)Java面向对象之细谈线程、线程通信(上)

线程与进程的关系：

进程 --运行中的程序。进程有如下特征：
1).独立性。拥有自己的资源，拥有自己独立的内存区。
   通常来说，一个进程的内存空间，是不允许其他进程访问的。
   但像Windows，如A进程可以通过某种方式修改其他进程的内存值。
2).动态性。程序是静止的，运行起来才叫进程。
3).并发性。一个操作系统可以同时“并发(concurrent)”运行多个进程。 
线程 --进程中的“并发(concurrent)”执行流，轻量级进程。

线程与进程的典型区别：Process(进程)是有独立内存的，因此创建Process的成本比创建线程的成本高。

什么是“并发”？什么是“并行”？
    1）并发：即使只有一个CPU，多个进程、或多个线程在CPU上【快速轮换】的执行。在同一个时刻，只有与CPU个数相同的进程真正在执行，其他进程都处于等待状态。--对用户来说，[感觉]是多个进程在同时执行。

    2）并行(Parallel)：必须有一个以上的cpu，在同一时刻，至少有与CPU个数相同的进程[真正]在执行。

多线程的好处：
    1）功能上类似多进程；
    2）创建成本低，效率高；
    3）所有线程共享进程的内存，因此线程之间的通信非常方便。

Java创建多线程的方法(3种)：(注意 Java默认有个main方法主线程的执行体)

启动线程：调用Thread对象的start()方法，千万不要调用run()方法。就是普通方法的调用，就不会启动多线程了。
a)继承Thread，重写一个run()方法，---这个run方法就是线程执行体(就是该线程将要做的事情)。
举列说明1：

public class Test extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			// Thread.currentThread()用于获取当前正在运行的线程
			System.out.println(Thread.currentThread().getName() + ",i=" + i);
		}
	}


	public static void main(String[] args) {
		new Test().start();// 创建匿名实例并启动线程
	}
}

b)实现Runnable接口，重写run方法。--推荐
举例说明2：

public class Test implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			// Thread.currentThread()用于获取当前正在运行的线程
			System.out.println(Thread.currentThread().getName() + ",i=" + i);
		}
	}


	public static void main(String[] args) {
		new Thread(new Test()).start();// 这里把Runnable对象包装成Thread对象。
	}
}

c)实现Callable（就是Runnable增强版），重写call方法(有返回值，可以声明抛出异常)。
举例说明3：

public class Test implements Callable<Integer> {
	@Override
	public Integer call() throws Exception {
		for (int i = 0; i < 100; i++) {
			// Thread.currentThread()用于获取当前正在运行的线程
			System.out.println(Thread.currentThread().getName() + ",i=" + i);
		}
		return 100;
	}


	public static void main(String[] args) {
		// 将Callable包装成FutureTask,再包装成Thread,最后启动线程
		new Thread(new FutureTask<Integer>(new Test())).start();
		;
	}
}

创建线程方式的对比，创建线程的方式可分为2类：
1。继承Thread类；2。实现Runnable或Callable接口。

总的来说，实现接口的方式更好，原因如下：
1.实现接口之后，依然可以继承其他类；但如果继承了Thread类，就无法继承其他类了。
2.实现接口时，可以让多个线程共享同一个Runnable对象。可以更好的实现代码与数据的分离，形成更清晰的逻辑。

线程的状态(当调用start()方法之后，只是启动了线程，线程并不会立即执行)：
新建：刚刚创建出来的Thread对象。
就绪：调用start()之后，处于就绪状态。
从就绪到运行：是不可控的，靠线程调度器来分配。
从就绪到运行：靠线程调度器来分配(yield()方法可以主动的让出cpu，进入就绪状态)。
阻塞：调用sleep()、IO阻塞、等待同步锁、等待通知等将进入阻塞Blocked状态；sleep()时间到、IO阻塞解除、获取同步锁、收到通知后等将进入就绪状态。
正常死亡：线程执行体执行完成；遇到了未捕获的异常。

控制线程的方法：

Join线程：启动一条线程，多条线程并发执行，被joined线程必须先执行完成。
举例说明：

class JoinThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			// Thread.currentThread()用于获取当前正在运行的线程
			System.out.println(Thread.currentThread().getName() + ",i=" + i);
		}
	}
}


public class Test {
	public static void main(String[] args) throws InterruptedException {
		JoinThread jt1 = new JoinThread();
		JoinThread jt2 = new JoinThread();
		for (int i = 0; i < 100; i++) {
			System.out.println("主线程正在执行：i=" + i);
			if (i == 20) {
				// 主线程执行到此处时,必须等到jt1、jt2执行完后,主线程才能继续向下执行。
				jt1.start();
				// 將jt1这条进程join进来, 等待jt1线程终止。
				jt1.join();
				jt2.start();
				jt2.join();
			}
		}
	}
}

后台线程(Daemon Thread)：又称守护线程、精灵线程。如果所有的前台线程结束，它会自动死亡。JVM的垃圾回收器就是一个典型的后台进程。调用Thread对象的setDaemon(true)方法可将指定线程设置为后台线程。

线程暂停：Thread.sleep(100)：让线程暂停100ms，并且进入阻塞状态。--推荐(更稳定)
线程让步：Thread.yield()：让线程让出cpu，并进入就绪状态。

改变线程的优先级：优先级越高，线程会获得更多的执行机会。
举例说明：(优先级高的先执行)

class PriorityThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			// Thread.currentThread()用于获取当前正在运行的线程
			System.out.println(Thread.currentThread().getName() + ",i=" + i);
		}
	}
}


public class Test {
	public static void main(String[] args) throws InterruptedException {
		PriorityThread jt1 = new PriorityThread();
		jt1.setPriority(Thread.MIN_PRIORITY);
		PriorityThread jt2 = new PriorityThread();
		jt2.setPriority(Thread.MAX_PRIORITY);
		jt1.start();
		jt2.start();
		System.out.println("~~~~~~主线程结束~~~~~");
	}
}