一、线程和进程的区别
在操作系统中所有运行的任务通常对应一个进程，进程是系统进行资源分配和调度的一个独立单位。线程是进程的组成部分，一个进程最少包含一个线程。并发和并行的区别是，并发指的在同一时刻内，多个指令在多个处理器上同时执行。并发指的是同一个时刻内一个只有一条指令执行，但多个进程指令被快速轮换执行。使得宏观上感觉是多个进程在同时执行。多个线程共享进程的内存资源和数据资源等。而多个进程之间不能共享内存。
JAVA实现多线程有三种方式：1、继承thread类 2、实现runnable 3、使用Callable和future创建多线程
二、线程的使用方式
第一种方式 继承Thread
package cn.test.hf; /**
* 继承thread实现多线程
*/
public class CreateThread extends Thread { private int i; public void run() { for (i = 0; i < 100; i++) { // 打印出当前这个线程的名称
System.out.println(this.getName() + "----" + i + "-------" + System.currentTimeMillis());
} } public static void main(String[] args) { for (; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "----" + i + "-------" + System.currentTimeMillis());
if (i == 20) { // 创建两个线程
CreateThread thread1 = new CreateThread();
thread1.start();
CreateThread thread2 = new CreateThread();
thread2.start();
}
} }
}
从结果可以看出，当主线程跑到i=20的时候，开始去执行子线程，同时主线程还是在运行着(是否分配了不同的CPU，那么就是并发的运行，如果是单个的话那么就是时间片轮转)。使用继承thread类的方式去实现多线程，实例变量不能共享。类变量可以共享。
第二种方式：实现Runnable
package cn.test.hf;
public class RunnableTest implements Runnable {
public void run() {
System.out.print("线程名称：" + Thread.currentThread().getName());
}
public static void main(String[] args) {
RunnableTest r = new RunnableTest();
new Thread(r,"线程1").start();
new Thread(r,"线程2").start();
}
}
这种方式由于使用的是同一个对象，所以实例遍历可以共用。
第三种方式：实现Callable接口，这种实现多线程的方式和runnable类似，只不过Callable方式会带有返回值。
package cn.test.hf; import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask; public class CallableTest implements Callable { public Object call() throws Exception { return 1;
} public static void main(String[] args) { try {
CallableTest call = new CallableTest();
FutureTask future = new FutureTask(call); new Thread(future).start();
System.out.print(future.get());
} catch (Exception e) { }
}
} 三种实现多线程的方式对比：实现Runnable和实现Callable方式的优点有1、还可以实现其他的类，可扩展。2、多个线程可以共享同一个target对象，可以共享数据。在代码结构层次可以将CPU、数据、代码分开，形成清晰的模型。
继承Thread类实现多线程用点是编程方便。三种方式推荐使用Runnable和Callable+Future。 三、线程的生命周期
1、新建（New）
程序使用New创建一个线程对象后，该线程的状态处于新增状态，仅仅由JAVA虚拟机为其分配内存，初始化其成员变量的值。
2、就绪（Runnable）
调用线程的start方法会将线程改变为就绪状态，还差获得CPU
3、执行（Running）
线程就绪状态获得CPU进入执行状态。
4、阻塞（Blocked）
线程调用sleep方法主动放弃CPU、线程调用了阻塞式IO方法、线程试图获取一个同步监视器，但是被其他线程所持有、线程在等待某个通知、程序调用了线程的suspend方法将其挂起的时候线程会进入阻塞。阻塞的线程获得某些资源后会进入就绪状态，等待获得调度获得CPU，不会直接进入执行状态。
5、死亡（Dead）
线程执行完后就会消亡。使用isAlive方法可以检测线程是否死亡，新建和死亡的线程会返回false、其他的返回true。 四、控制线程
1、join线程，Thread提供了让线程等待另一个线程的方法join()
package cn.test.hf;
public class RunnableTest implements Runnable {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程名称：" + Thread.currentThread().getName() + "=====" + i);
}
}
public static void main(String[] args) {
try {
RunnableTest r = new RunnableTest();
Thread t1 = new Thread(r, "线程1");
t1.start();
t1.join();
Thread t2 = new Thread(r, "线程2");
t2.start();
for (int i = 0; i < 1000; i++) {
System.out.println("线程名称：" + Thread.currentThread().getName() + "=====" + i);
}
} catch (Exception e) {
}
}
}
2、后台线程又称为守护线程，JVM垃圾回收就是典型的一个守护线程，守护线程会在所有前台线程死亡后再死亡。使用DaemonThread可以将线程设置为后台线程。
3、线程休眠，调用sleep方法，会将线程变为阻塞状态。
4、线程让步，调用yield方法，会使线程让出CPU进入就绪状态，而不是阻塞当前线程。调用之后其他比当前线程优先级高的线程将会获得CPU。
五、线程的优先级
子线程的优先级默认与其父线程优先级一致，main主线程的优先级为普通优先级，通过Thread的setPriority方法可以设置线程的优先级，范围为1-10.