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 extendsThread{
public void run(){ //重写run方法
for(int i=0;i<100;i++){
System.out.println("自定义线程"+i)
}
}
public static voidmain(String[] args){
Demo d = newDemo();
d.start(); //调用start方法开启线程
for(int i=0;i<100;i++){
System.out.println("main线程"+i)
}
}
}方式二：实现Runnable接口，Thread类中有构造方法，可以传递Runnable实例。
class Demo1 implementsRunnable{
public void run(){ //重写run方法
for(int i=0;i<100;i++){
System.out.println("自定义线程"+i)
}
}
public static voidmain(String[] args){
Demo d = newDemo();
Thread thread = newThread(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对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
实现代码：
packagexiancheng.callable;importjava.util.concurrent.Callable;public class MyCallable implements Callable{
@Overridepublic Integer call() throwsException {int sum = 0;for(int i = 0;i<10;i++){
sum+=i;
}returnsum;
}
}
public classCallableTest {public static void main(String[] args) throwsException{/*// 第一种方式：通过线程池来获取线程
ExecutorService executor = Executors.newCachedThreadPool();//创建线程池
Future future = executor.submit(new MyCallable());//ExecutorService中的submit方法接受一个Runnable或者Callable，然后返回一个Future来获得任务的执行结果或者取消任务。
System.out.println("result:" + future.get());
executor.shutdown();*/
//第二种方式
MyCallable mc = newMyCallable();
FutureTask futureTask = new FutureTask(mc);
Thread thread= newThread(futureTask);
thread.start();
System.out.println("result:" +futureTask.get());
}
}结果为：result：45
5.实例变量与线程安全
场景一：数据不共享情况
public class MyThread extendsThread{private int i = 5;publicMyThread(String s){super();this.setName(s);
}public voidrun(){super.run();while(i>0){
i--;
System.out.println("由"+Thread.currentThread().getName()+"计算i="+i);
}
}
}
public classRun {public static voidmain(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 extendsThread{private int i = 5;public voidrun(){super.run();
i--;
System.out.println("由"+Thread.currentThread().getName()+"计算i="+i);
}
}
public classRun {public static voidmain(String[] args) {
MyThread myThread= newMyThread();
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();
}
}运行结果：
线程A，C，B打印出相同的数字，说明产生了线程安全问题，我们想要的结果是递减的。
解决方法：
public class MyThread extendsThread{private int i = 5;synchronized public voidrun(){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()方法，该线程结束生命周期。
