1. 线程、进程、多线程：
进程是正在执行的程序，线程是进程中的代码执行，多线程就是在一个进程中有多个线程同时执行不同的任务，就像QQ，既可以开视频，又可以同时打字聊天。
2.线程的特点：
1.运行任何一个java程序，jvm在运行时都会创建一个main线程来执行main方法。
2.一个java应用程序至少有两个线程，一个是主线程，负责main方法的执行，一个是垃圾回收器线程，负责回收垃圾。
3.我们可以利用Thread.currentThread().getName()获得当前线程名字。
3.多线程的优点：
1.可以同时处理多个任务。
2.提高资源的利用率。
缺点：
1.增加了CPU负担，因为CPU要不断的来回切换。
2.降低了一个进程中线程的执行概率。
3.存在线程安全问题。
4.会发生死锁现象。
4.如何创建一个线程：
方式一： 1.自定义一个类继承Thread类；
2.重写Thread类中的run方法（自定义线程的任务代码就放在run方法里）；
3.创建Thread子类的对象，并且调用start方法开启线程。（run方法不能直接调用）
class Demo extends Thread{
public void run(){ //重写run方法
for(int i=0;i<100;i++){
System.out.println("自定义线程"+i)
}
}
public static void main(String[] args){
Demo d = new Demo();
d.start(); //调用start方法开启线程
for(int i=0;i<100;i++){
System.out.println("main线程"+i)
}
}
}
方式二：实现Runnable接口，Thread类中有构造方法，可以传递Runnable实例。
class Demo1 implements Runnable{
public void run(){ //重写run方法
for(int i=0;i<100;i++){
System.out.println("自定义线程"+i)
}
}
public static void main(String[] args){
Demo d = new Demo();
Thread thread = new Thread(d);
thread .start(); //调用start方法开启线程
for(int i=0;i<100;i++){
System.out.println("main线程"+i)
}
}
}
方式三：实现Callable接口
* Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
* Callable和Runnable有几点不同：
* （1）Callable规定的方法是call()，而Runnable规定的方法是run().
* （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
* （3）call()方法可抛出异常，而run()方法是不能抛出异常的。
* （4）运行Callable任务可拿到一个Future对象，
* Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
* 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
实现代码：
package xiancheng.callable;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
int sum = 0;
for(int i = 0;i<10;i++){
sum+=i;
}
return sum;
}
}
public class CallableTest {
public static void main(String[] args) throws Exception{
/*// 第一种方式：通过线程池来获取线程
ExecutorService executor = Executors.newCachedThreadPool();//创建线程池
Future<Integer> future = executor.submit(new MyCallable());//ExecutorService中的submit方法接受一个Runnable或者Callable，然后返回一个Future来获得任务的执行结果或者取消任务。
System.out.println("result:" + future.get());
executor.shutdown();*/
//第二种方式
MyCallable mc = new MyCallable();
FutureTask<Integer> futureTask = new FutureTask<Integer>(mc);
Thread thread = new Thread(futureTask);
thread.start();
System.out.println("result:" + futureTask.get());
}
}
结果为：result：45
Executors、ExecutorService介绍请移步Java多线程学习笔记（二）——Executor,Executors,ExecutorService比较
Future、FutureTask介绍请移步Java多线程学习笔记（三）——Future和FutureTask
5.实例变量与线程安全
场景一：数据不共享情况
public class MyThread extends Thread{
private int i = 5;
public MyThread(String s){
super();
this.setName(s);
}
public void run(){
super.run();
while(i>0){
i--;
System.out.println("由"+Thread.currentThread().getName()+"计算i="+i);
}
}
}
public class Run {
public static void main(String[] args) {
MyThread a = new MyThread("A");
MyThread b = new MyThread("B");
MyThread c = new MyThread("C");
a.start();
b.start();
c.start();
}
}
运行结果：
我们创建三个独立的线程，每个线程有自己的变量。不会出现安全问题。
场景二：五个售票员卖票
public class MyThread extends Thread{
private int i = 5;
public void run(){
super.run();
i--;
System.out.println("由"+Thread.currentThread().getName()+"计算i="+i);
}
}
public class Run {
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread a = new Thread(myThread,"A");
Thread b = new Thread(myThread,"B");
Thread c = new Thread(myThread,"C");
Thread d = new Thread(myThread,"D");
Thread e = new Thread(myThread,"E");
a.start();
b.start();
c.start();
d.start();
e.start();
}
}
public class MyThread extends Thread{
private int i = 5;
synchronized public void run(){
super.run();
i--;
System.out.println("由"+Thread.currentThread().getName()+"计算i="+i);
}
}
运行结果：
由A计算i=4
由D计算i=3
由C计算i=2
由B计算i=1
由E计算i=0
6.线程生命周期：
1.创建阶段：当创建线程的继承类时就实现这一阶段。new Demo();
2.可运行阶段：当调用start方法时。
3.运行状态：线程拿到CPU执行权时。当执行权被夺走时又会回到可运行阶段。
4.临时阻塞状态：是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入可运行阶段，才有机会转到运行状态。
临时阻塞状态又分为三种：
1)等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
2)同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
3)其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行状态。
5.死亡状态：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。