进程定义：
狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。
它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
线程定义：
线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。
一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
进程和线程的区别
进程是操作系统进行资源分配的最小单元。线程是操作系统进行任务分配的最小单元。线程隶属于进程。
线程状态：
public enum State {
NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;
}
- New：新创建的一个线程，处于等待状态。
- Runnable：可运行状态，并不是已经运行，具体的线程调度各操作系统决定。在 Runnable 中包含了 Ready、Running 两个状态，当线程调用了 start() 方法 后，线程则处于就绪 Ready 状态，等待操作系统分配 CPU 时间片，分配后则进 入 Running 运行状态。此外当调用 yield() 方法后，只是谦让的允许当前线程让 出 CPU，但具体让不让不一定，由操作系统决定。如果让了，那么当前线程则会处 于 Ready 状态继续竞争 CPU，直至执行。
- Timed_waiting：指定时间内让出 CPU 资源，此时线程不会被执行，也不会被 系统调度，直到等待时间到期后才会被执行。下列方法都可以触发： Thread.sleep、Object.wait、Thread.join、 LockSupport.parkNanos、LockSupport.parkUntil。
- Wating：可被唤醒的等待状态，此时线程不会被执行也不会被系统调度。此状态 可以通过 synchronized 获得锁，调用 wait 方法进入等待状态。最后通过 notify、notifyall 唤醒。下列方法都可以触发：Object.wait、 Thread.join、LockSupport.park。
- Blocked：当发生锁竞争状态下，没有获得锁的线程会处于挂起状态。例如 synchronized 锁，先获得的先执行，没有获得的进入阻塞状态。 Terminated：这个是终止状态，从 New 到 Terminated 是不可逆的。一般是程 序流程正常结束或者发生了异常
线程的创建和使用
可参考：https://my.oschina.net/u/1156250/blog/5014067
线程设置优先等级
package com.pimee.thread.priority;
/**
* 继承Thread创建线程 线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级
*
* @author Bruce Shaw
*
*/
public class PriorityThread extends Thread {
public String name;
public PriorityThread(String name) {
this.name = name;
}
public static void main(String[] args) throws InterruptedException {
String name1 = "priority1";
PriorityThread test1 = new PriorityThread(name1);
test1.setPriority(MIN_PRIORITY);
test1.start();
String name2 = "priority2";
PriorityThread test2 = new PriorityThread(name2);
test2.setPriority(MAX_PRIORITY);
test2.start();
// Thread.sleep(500);
System.out.println("This is MainThread...");
}
@Override
public void run() {
System.out.println("This is " + this.name + "...");
}
}
线程插队
package com.pimee.thread.method;
/**
* 线程插队
*
* @author Bruce Shaw
*
*/
public class MainJoinThread extends Thread {
public String name;
public MainJoinThread(String name) {
this.name = name;
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 5; i++) {
JoinThread joinThread = new JoinThread("JoinThread-" + i);
MainJoinThread mainJoinThread = new MainJoinThread("MainJoinThread-" + i);
mainJoinThread.start();
// 保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。
mainJoinThread.join();
joinThread.start();
}
}
@Override
public void run() {
System.out.println(name + " is running...");
}
}
class JoinThread extends Thread {
public String name;
public JoinThread(String name) {
this.name = name;
}
@Override
public void run() {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + " is running...");
}
}
线程让出执行权
/**
* 线程让出执行权
*
* @author Bruce Shaw
*
*/
public class YieldThread extends Thread {
public String name;
public YieldThread(String name) {
this.name = name;
}
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("This is " + name);
}
public static void main(String[] args) {
YieldThread yield1 = new YieldThread("yield1");
YieldThread yield2 = new YieldThread("yield2");
yield1.start();
Thread.yield(); // 线程让出执行权
yield2.start();
}
}
后台线程
/**
* 后台线程
*
* @author Bruce Shaw
*
*/
public class DaemonThread extends Thread {
public static void main(String[] args) {
DaemonThread test = new DaemonThread();
test.setDaemon(true);
test.start();
}
@Override
public void run() {
System.out.println("This is DaemonThread...");
}
}
