进程：当前正在运行的程序，一个应用程序在内存中的执行区域
线程：进程中的一个执行控制单元，执行路径
一个进程可以有一个线程，也可以有多个线程
单线程：安全性高，但是效率低
多线程：安全性低，效率高
多线程案例：360，迅雷等
1、程序运行原理
分时调度：所有线程轮流使用cpu的使用权，平均分配每个线程占用cpu的时间
抢占式调度：优先让优先级高的线程使用cpu，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度。
抢占式调度
大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，“感觉这些软件好像在同一时刻运行着”。
实际上，cpu（中央处理器）使用抢占式调度模式在多个线程间进行着高速的切换。对于cpu的一个核而言，某个时刻，只能执行一个线程，而cpu的在多个线程间切换速度相对我们感觉要快，看上去就是在同一时刻运行。
其实，多线程并不能提高程序的运行速度，但能够提高程序运行速率，让cpu的使用率更高。
2、线程的使用
在Java中创建线程的方法有两种
方法一：
继承java.lang.Thread类
继承Thread类
自定义一个类继承Thread类
重写Thread的run方法
创建一个该类的对象
使用该类对象调用start方法开启线程
package LESSON13; public class MyThread extends Thread{ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println( getName()+":"+i);//调用父类方法getName
//System.out.println("i"+i+"当前线程："+Thread.currentThread().getName()); } } }
package LESSON13; public class ThreadDemo1 { public static void main(String[] args) { MyThread mt1 = new MyThread(); mt1.start();//使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 mt1.setName("张三"); MyThread mt2 = new MyThread(); mt2.start(); mt2.setName("老王");
//MyThread myThread01 = new MyThread("红色线程");//也可创建对象时直接赋予名称，输出时使用Thread.currentThread().getName()得到名称
//MyThread myThread02 = new MyThread("蓝色线程"); } }
方法二：
实现java.lang.Runnable接口
好处：面向接口编程，低耦合
实现Runnable接口
自定义一个类实现Runnable接口
重写Thread的run方法
创建一个该类的对象
使用Thread(Runnable target)构造方法创建Thread类对象
使用Thread类对象调用start方法开启线程
package LESSON13; public class MyRunnable implements Runnable { @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(i);
//System.out.println("i"+i+"线程名称:"+Thread.currentThread().getName()); } } }
package LESSON13; public class RunnableDemo { public static void main(String[] args) { MyRunnable mr = new MyRunnable();//MyRunnable实现Runnable接口，也属于Runnable类型 Thread t = new Thread(mr);//使用Thread(Runnable target)构造方法创建Thread类对象 t.start();
//MyRunnable mr = new MyRunnable();
//Thread t = new Thread(mr,"黄色线程");//创建对象时直接赋予名称
//t.start(); } }
3、使用匿名内部类
使用线程的内匿名内部类，可以方便的实现每个线程执行不同的线程任务操作。
方式一：创建线程对象时，直接重写Thread类中的run方法
package com.zy.dmeo03; public class Demo03 { public static void main(String[] args) { // 使用匿名内部类的方式()一般都有重写的发生，简化线程开发步骤 //创建线程，和指定任务一气呵成 new Thread(){//发生了重写 说明一定有一个类重写了Thread中的run方法 只是这个类没有名字（匿名） @Override//重写 public void run() { for (int a = 0; a < 200; a++) { System.out.println("a"+a); } } }.start();//调用start方法说明产生了一个对象(只有对象才能调用方法) //实际上有一个类重写了Thread中的run方法，并且产生了一个匿名子类对象，然后调用start方法 //1为什么匿名内部类------class Demo03中还有一个内部类，只是没有名字 //重写：1子类重写父类方法，2实现类重写接口方法 //----------------------------------------------- new Thread(){ @Override public void run() { for (int b = 0; b < 200; b++) { System.out.println("b"+b); } } }.start(); //以上代码创建了两个线程，并开启了两个线程 } }
方式2：使用匿名内部类的方式实现Runnable接口，重写Runnable接口中的run方法
package com.zy.dmeo03; public class Demo04 { public static void main(String[] args) { // TODO Auto-generated method stub new Thread( //new 一个接口 new Runnable() {//Runnable实现类(匿名) @Override//重写 public void run() { for (int a = 0; a < 200; a++) { System.out.println("a"+a); } } } //整体就是一个匿名的runnbale实现类对象 ).start(); //new Thread(runnbale实现类对象).start new Thread( new Runnable() { @Override public void run() { for (int b = 0; b < 200; b++) { System.out.println("b"+b); } } } ).start(); } }
4、线程池
线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去l频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。
线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。
package com.zy.demo04; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class MyPool { public static void main(String[] args) throws Exception { // 使用线程池，创建和管理线程------提高效率 //使用Executors工厂，创建线程池对象，保留3预备线程 ExecutorService pool = Executors.newFixedThreadPool(3); //池对象，提交任务 ExecutorService pool2 = pool; pool2.submit(//执行该任务会从该线程池中取出一个空闲的线程 new Runnable() { @Override public void run() { System.out.println("我的任务1"); } } ); pool2.submit(//执行该任务会从该线程池中取出一个空闲的线程 new Runnable() { @Override public void run() { System.out.println("我的任务2"); } } ); pool2.submit(//执行该任务会从该线程池中取出一个空闲的线程 new Runnable() { @Override public void run() { System.out.println("我的任务3"); } } ); //pool.shutdown();//结束 线程池一般处于等待执行状态,在程序中一般不需要关闭 Future<String> ft = pool.submit(new Callable<String>() { @Override public String call() throws Exception { System.out.println("任务5"); return "奖励一瓶矿泉水"; } }); System.out.println(ft.get()); } }
5、线程原理
在某一个时间段内，多个线程在CPU上交替运行，给人的感觉是“同时”执行。
实际上，在某一个时间点上，只能在CPU上运行一个线程。
原理：
1.线程启动之后，会先到CPU调度队列中排队，CPU会计算各线程优先级确定队里线程的先后顺序，挑选优先级最高的线程运行。
2.CPU运行某个线程，会给该线程分配运行的时间片，如果时间片到期，该线程自动退出CPU，然后重新排队。
3.该线程再一次运行在CPU上，接着上一次运行的位置继续向后运行，直到运行结束，线程死亡。
sleep方法
void sleep(long time)方法用于使当前线程休眠指定的毫秒数
特点：
让当前线程退出CPU的运行，处于阻塞（休眠）状态；一旦进入阻塞状态不会排队，但是该线程所持有的对象的锁不会释放；休眠一段时间后，结束阻塞，重新排队。
join方法
利用sleep方法对线程的控制是非常不精确的，然而 join方法可以精确控制线程。
void join() 等待该线程终止后再运行
void join(long millis) 等待线程运行多少毫秒后再运行
特点：
让当前线程退出CPU的运行，处于阻塞状态；直到调用的线程执行完毕后结束阻塞，重新排队。如果当前线程中调用了另外一个线程的 join方法，当前线程会立即阻塞，直到另外一个线程运行完成。
问题：
如果2个线程彼此调用对方的join方法，会导致程序无法进行。
解决办法：throws InterruptedException
6、线程同步
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
其实，线程安全问题都是由全局变量即静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时操作写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
产生数据不一致的原因
多个线程并发访问了同一个对象，如果破坏了不可分割的操作， 从而就会造成数据不一致，被多线程并发访问时如果一个对象有可能出现数据不一致的问题，那么这个对象称为线程不安全的对象。
如何解决多线程并发访问的问题
方式1：同步代码块
synchronized(锁对象){
可能会产生线程安全问题的代码
}
同步代码块中的锁对象可以使任意的对象；但多个线程是，要是用同一个锁对象才能够保证线程安全。
package com.zy.demo05; public class Demo05 { public static void main(String[] args) throws Exception { for (int a = 0; a < 200; a++) { Thread.sleep(1000);//毫秒//休眠 该线程在改时间内不抢夺cpu的使用权 System.out.println("*"); } } }
方式2：同步方法
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步方法中的锁对象是this
package com.zy.demo06; public class Demo06 { public static synchronized void show(){//保护方法(线程同步) for (int a = 0; a < 200; a++) { } }//在该方法运行期间不会被抢走，方法结束后才允许别的线程抢夺 }
静态同步方法：在方法声明上加上static synchronized
public static synchronized void method(){
可能会产生线程安全问题的代码
}
静态同步方法中的锁对象是类名.class
7、死锁
同步锁使用的弊端：当线程任务中出现了多个同步（多个锁）时，如果同步中嵌套了其他的同步。这时容易引发一众现象：程序出现无线等待，这种现象我们称为死锁。这种情况能避免就避免掉。
synchronized(A锁){
synchronized(B锁){
}
}
8、等待唤醒机制
在开始讲解等待唤醒机制之前，有必要搞清一个概念——线程之间的通信：多个线程在处理同一资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即——等待唤醒机制。
其实，所谓唤醒的意思就是让线程池的线程具备执行资格。必须注意的是，这些方法都是在同步中才能生效。同时这些方法在使用时必须标明所属锁，这样才可以明确这些方法操作的到底是那个锁上的线程。