目录
一.什么是线程.
任务调度: 时间片轮转抢占式调度方式.一个任务执行一小段时间后,强制暂停去执行下一个任务.每个任务轮流执行.被暂停的任务就
处在就绪状态, 等待下一个属于他的时间片的来临.这样每个任务都能进行执行.
时间片非常短，在各个任务之间快速地切换，给人的感觉就是多个任务在“同时进行”，
这也就是我们所说的并发(concurrent)
并发和并行(parallel /'pærəlel/)的区别:
并发是在一个时间段上执行多个线程. 在一个时间点上只有一个线程执行.宏观山的一起执行. 一个人 同时吃三个馒头
并行(parallel) 在一个时间点上有多个线程在执行.在宏观和微观上都是多个线程一起执行的. 三个人同时吃三个馒头
进程:
计算机的核心是CPU(Central Processing Unit)它承担了所有的计算任务；而操作系统是计算机的管理者，它负责任务的调度、资源的分配和管理，统领整个计算机硬件；应用程序侧是具有某种功能的程序，程序是运行于操作系统之上的
进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序、数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块(Program Control Block，简称PCB)，包含进程的描述信息和控制信息，是进程存在的唯一标志。
进程具有的特征：
动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的；
并发性：任何进程都可以同其他进程一起并发执行；
独立性：进程是系统进行资源分配和调度的一个独立单位；
结构性：进程由程序、数据和进程控制块三部分组成。
线程
在早期的操作系统中并没有线程的概念，进程是能拥有资源和独立运行的最小单位，也是程序执行的最小单位。任务调度采用的是时间片轮转的抢占式调度方式，而进程是任务调度的最小单位，每个进程有各自独立的一块内存，使得各个进程之间内存地址相互隔离。
随着计算机的发展，对CPU的要求越来越高，进程之间的切换开销较大，已经无法满足越来越复杂的程序的要求了。于是就发明了线程，线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位。一个进程可以有一个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。一个标准的线程由线程ID、当前指令指针(PC)、寄存器和堆栈组成。而进程由内存空间(代码、数据、进程空间、打开的文件)和一个或多个线程组成。
线程和进程的区别:
1.线程是程序执行的最小单位, 进程是操作系统分配资源的最小单位.
2.一个进程由一个或者多个线程组成.线程是一个进程中代码的不同执行路线.
3.进程之间相互独立, 但是同一进程中的各个线程是共享程序内存空间的(Java 的内存模型中 heap,permanent)
4.调度和切换: 线程的切换要比进程快.
二.线程的生命周期:
三.Java线程的创建
1.线程创建的方式.
- 继承Thread类创建线程
- 实现Runnable接口创建线程
- 使用Callable和Future创建线程
继承Thread类创建线程
1】定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。
2】创建Thread子类的实例，也就是创建了线程对象
3】启动线程，即调用线程的start()方法
public class ExtendsThread {
public static void main(String[] args) {
//此时一共由三个线程. main mt mt2
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i + "======");
if (i == 5) {
MyThread mt1 = new MyThread( );
mt1.setName("线程1: ");
MyThread mt2 = new MyThread( );
mt2.setName("线程2: ");
//将mt2设置成了优先级最高, 但是也不一定是最先执行的.
mt2.setPriority(Thread.MAX_PRIORITY);
mt2.start();
mt1.start();
}
}
}
}
class MyThread extends Thread {
@Override
public void run() {
System.out.println(getName()+"................");
}
}实现Runnable 接口创建线程
1】定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体
2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象
3】第三部依然是通过调用线程对象的start()方法来启动线程
public class MyThread2 implements Runnable {
//实现Runnable接口
public void run(){
//重写run方法
}
}
public class Main {
public static void main(String[] args){
//创建并启动线程
MyThread2 myThread=new MyThread2();
Thread thread=new Thread(myThread);
thread().start();
//或者 new Thread(new MyThread2()).start();
}
}实现Callable接口开启线程
和Runnable接口不一样，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。
>>>call()方法可以有返回值
>>>call()方法可以声明抛出异常
Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
>boolean cancel(boolean mayInterruptIfRunning)：视图取消该Future里面关联的Callable任务
>V get()：返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值
>V get(long timeout,TimeUnit unit)：返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException
>boolean isDone()：若Callable任务完成，返回True
>boolean isCancelled()：如果在Callable任务正常完成前被取消，返回True
1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
public class ImplCallable {
public static void main(String[] args) {
Target target=new Target();
FutureTask<Integer> futureTask=new FutureTask<Integer>(target);
Thread thread=new Thread(futureTask);
thread.start();
try {
System.out.println(Thread.currentThread().getName()+":\t"+futureTask.get());
} catch (Exception e) {
// TODO: handle exception
}
}
}
class Target implements Callable<Integer> {
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
return 1;
}
}
//返回结果:
//Thread-0
//main: 1
三种方式的区别:
实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值，因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：
1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。
2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
3、但是编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。
4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）。
注：一般推荐采用实现接口的方式来创建多线程
2.线程池:
什么是线程池:
java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。
如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
一个线程池包括以下四个基本组成部分：
1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；
2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：
假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。
线程池的作用：
线程池作用就是限制系统中执行线程的数量。
根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。
为什么要用线程池:
1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
常见的线程池:
①newSingleThreadExecutor()
单个线程的线程池，即线程池中每次只有一个线程工作，单线程串行执行任务
②newFixedThreadPool(int)
固定数量的线程池，没提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行
③newCachedThreadPool()（推荐使用）
可缓存线程池，当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行。
④newScheduledThreadPool(int)
大小无限制的线程池，支持定时和周期性的执行线程
Executor 接口表示线程池, 他的execute(Runnable task)方法用来执行Runnable类型的任务
Executor的子接口 ExecutorService 中声明了管理线程池的一些方法.比如关闭线程池的方法.shutdow()
Executors 类中包含了一些静态方法,他们用来生成各种类型的线程池ExecutorService实例
3.本地线程变量ThreadLocal
什么是ThreadLocal
防止任务在共享资源上产生冲突的第二种方式是根除对变量的共享。线程本地存储是一种自动化机制，可以为使用相同变量的每个不同线程都创建不同的存储”。（第一种方式就是进行同步控制，比如加锁）
每个线程自己的本地变量。简单的来说，就是在多线程的程序中，我们一般会申请共享变量。给所有线程使用。但是很多情况下，每个线程会对共享变量进行改变。比如，一个String 类型的static变量，线程一将String 赋值为 “线程一”，然后在跑其他的逻辑的时候，第二个线程将String 又改成了“线程二”，那么就会出个问题，线程一跑到后面在对该String进行使用的时候，就发现值已经被改变了。ThreadLocal的价值就体现了出来。就是在每个线程里面对变量单独记录保存。这样，线程二对String的改变就是对自己内部改变，不会影响别的线程中的String值。
ThreadLocal不是一个特殊的Thread，它只是一个线程的局部变量(其实就是一个Map用于存储每一个线程的变量副本，Map中元素的Key为线程对象，而Value对应线程的变量副本),ThreadLocal会为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。 对于多线程资源共享的问题，同步机制(Synchronized)采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
如果线程自然死亡，那么ThreadLcoal的数据也会跟着消失，如果是线程池，在线程会被复用的情况下，要手动清除。可以把map中的值set成null，让GC可以工作，也可以调用ThreadLocal的remove方法。
并发编程实战这本书里也提到ThreadLocal会降低代码的可重用性，并在类之间引入隐含的耦合性，因此在使用时要格外小心。
有位博主说过，对于Java线程，自己写线程或者线程池的机会挺少的，都被类库或者框架给封装好了，我们要做的其实就是要理解概念和思路，以及别人是怎么给我们实现的。
ThreadLocal源码:
在Thread类中有个ThreadLocalMap
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
map的键值对是:
Entry(ThreadLocal<?> k, Object v)
就是这个map在每个Thread里存了ThreadLocal对象和对应的其他某个对象，这里的某个对象就可以是我们说的苹果。
ThreadLocal类有两个重要方法 set 和 get ，
get就是获取这个ThreadLocal变量在当前类的值，源码如下
/**
* Returns the value in the current thread's copy of this
* thread-local variable. If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
可以看到这个方法先要获取当前线程的map，然后在 map 里面找 this ThreadLocal 变量对应的值。
如果这个对象没有值就调用setInitialValue()
/**
* Variant of set() to establish initialValue. Used instead
* of set() in case user has overridden the set() method.
*
* @return the initial value
*/
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
protected T initialValue() {
return null;
}
再看set，set就是给当前线程设置一个ThreadLocal变量对应的值，这个值是Object
/**
* Sets the current thread's copy of this thread-local variable
* to the specified value. Most subclasses will have no need to
* override this method, relying solely on the {@link #initialValue}
* method to set the values of thread-locals.
*
* @param value the value to be stored in the current thread's copy of
* this thread-local.
*/
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
GET 和 SET 都有这个一句
Thread t = Thread.currentThread();//就是定位到了当前线程。
ThreadLocal的使用场景:
并发应用的一个关键地方就是共享数据。如果你创建一个类对象，实现Runnable接口，然后多个Thread对象使用同样的Runnable对象，全部的线程都共享同样的属性。这意味着，如果你在一个线程里改变一个属性，全部的线程都会受到这个改变的影响。 有时，你希望程序里的各个线程的属性不会被共享。 Java 并发 API提供了一个很清楚的机制叫本地线程变量即ThreadLocal。 模拟ThreadLocal类实现：线程范围内的共享变量，每个线程只能访问他自己的，不能访问别的线程。
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
