程序、进程、线程

1、程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。

2、进程(process)：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。—生命周期

　　1）进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

3、线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

　　1）若一个进程同一时间并行执行多个线程，就是支持多线程的

　　2）线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小

　　3）一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发： 

　　1) 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

　　2) 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

多线程程序的优点：

　　1) 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

　　2) 提高计算机系统CPU的利用率

　　3) 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程

　　1）程序需要同时执行两个或多个任务。

　　2）程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

　　3）需要一些后台运行的程序时。

线程的创建和启动

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread 类来体现。

　　1）每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。

　　2）通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。

Thread类构造器

　　1）Thread()：创建新的Thread对象；

　　2）Thread(String threadname)：创建线程并指定线程实例名；

　　3）Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接 口中的run方法；

　　4）Thread(Runnable target, String name)：创建新的Thread对象。

---

API中创建线程的两种方式

JDK1.5之前创建新执行线程有两种方法：

　　1）继承Thread类的方式；

　　2）实现Runnable接口的方式；

1）：继承Thread类

1)  定义子类继承Thread类。 
2)  子类中重写Thread类中的run方法。
3)  创建Thread子类对象，即创建了线程对象。 
4)  调用线程对象start方法：启动线程，调用run方法。

package com.thread.test;

public class ThreadTest {
    public static void main(String[] args) {
        //3 创建Thread子类对象，即创建了线程对象。 
        MyThread m=new MyThread();
        //4 调用线程对象start方法：启动线程，调用run方法。
        m.start();
    }
}
//1 定义子类继承Thread类。
class  MyThread extends  Thread{
    //2 子类中重写Thread类中的run方法。
    @Override
    public  void  run(){
        for (int i = 0; i <100 ; i++) {
            System.out.println("子线程"+i);
        }
    }
}

2）：实现Runnable接口

1) 定义子类，实现Runnable接口。 
2) 子类中重写Runnable接口中的run方法。 
3) 通过Thread类含参构造器创建线程对象。 
4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。 
5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

package com.thread.test;

public class ThreadTest {
    public static void main(String[] args) {

//        3) 通过Thread类含参构造器创建线程对象。------------------------------创建实现类的对象
//        4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。-------将此对象作为参数传递Thread类构造器中，创建Thread类的对象
//        5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。---通过Thread类的对象调用start();
        new Thread(new MyThread2()).start();
    }
}

    // 1) 定义子类，实现Runnable接口。
class  MyThread2 implements  Runnable{
    //2) 子类中重写Runnable接口中的run方法。
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println("子线程"+i);
        }
    }
}

Thread类的有关方法

void start():  启动线程，并执行对象的run()方法 
run():  线程在被调度时执行的操作 
String getName():  返回线程的名称 
void setName(String name):设置该线程名称 
static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
static  void  yield()：线程让步 
　　暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程 
　　若队列中没有同优先级的线程，忽略此方法 
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将 被阻塞，直到 join() 方法加入的 join 线程执行完为止 
　　低优先级的线程也可以获得执行 
static  void  sleep(long millis)：(指定时间:毫秒) 
　　令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后 重排队。 
　　抛出InterruptedException异常 
stop(): 强制线程生命期结束，不推荐使用 
boolean isAlive()：返回boolean，判断线程是否还活着

线程的调度

1）调度策略

2）调度方法

　　1.同优先级线程组成先进先出队列（先到先服务），使用时间片策略

　　2.对高优先级，使用优先调度的抢占式策略

3）线程的优先级

　　1.等级，方法

MAX_PRIORITY：10 
MIN _PRIORITY：1 
NORM_PRIORITY：5 
getPriority() ：返回线程优先值 
setPriority(int newPriority) ：改变线程的优先级

　　线程创建时继承父线程的优先级 

　　低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

　　Java中的线程分为两类：一种是守护线程，一种是用户线程。

　　守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

　　Java垃圾回收就是一个典型的守护线程。

---

线程的生命周期

多线程出现了安全问题

　　当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误。

　　对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行。

线程的同步：Synchronized同步机制

同步机制中的锁：

在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防 止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法 就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须 锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁 之时，另一个任务就可以锁定并使用它了。

 synchronized的锁是什么？ 

　　任意对象都可以作为同步锁。

　　所有对象都自动含有单一的锁（监视器）。 

　　同步方法的锁：静态方法（类名.class）、非静态方法（this） 

　　同步代码块：自己指定，很多时候也是指定为this或类名.class

必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就 无法保证共享资源的安全 

　　1）同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），

　　2）同步代码块（指定需谨慎）。对于实现 Runnable 接口的方法，由于就一个实现类对象，所以可以用this 当锁。 对于继承Thread 类的方法，由于有多个子类的实例，所以需要使用 类名.class 当锁。

同步的方式，解决了线程的安全问题。---好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性

线程的通信：

* 涉及到的三个方法：
* wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
* notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
* notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
*
* 说明：
* 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
* 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。当前线程必须具有对该对象的监控权（加锁）
*    否则，会出现IllegalMonitorStateException异常
* 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
*
* 面试题：sleep() 和 wait()的异同？
* 1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
* 2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
*          2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
*          3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

package com.company;
// * 线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印
public class Comm {
    public static void main(String[] args) {
        CommThread th=new CommThread();
        Thread t1=new Thread(th,"线程1");
        Thread t2=new Thread(th,"线程2");

        t1.start();
        t2.start();
    }
}


class CommThread implements Runnable{
    private  int count=100;
    private  Object ob=new Object();
    @Override
    public void run() {
        while (true)
        {
           synchronized (ob)
           {
               ob.notify();
               if(count>0)
               {
                   System.out.println("xincheng"+Thread.currentThread().getName()+":"+count);
                   count--;
                   try {
                       ob.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               else
               {
                   break;
               }
           }
        }
    }
}

* 解决线程安全问题的方式三：Lock锁  --- JDK5.0新增
*
* 1. 面试题：synchronized 与 Lock的异同？
*   相同：二者都可以解决线程安全问题
*   不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
*        Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
*
* 2.优先使用顺序：
* Lock  同步代码块（已经进入了方法体，分配了相应资源）  同步方法（在方法体之外）
*
*
*  面试题：如何解决线程安全问题？有几种方式

package com.company;

import java.util.concurrent.locks.ReentrantLock;

public class MainLock {
    public static void main(String[] args) {
        Test th=new Test();
        Thread t1=new Thread(th,"窗口1");
        Thread t2=new Thread(th,"窗口2");
        Thread t3=new Thread(th,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }


}


class  Test implements Runnable{
    private  int ticket=100;
    ////1.实例化ReentrantLock
    private ReentrantLock Lock=new ReentrantLock();
    @Override
    public void run() {
        while (true)
        {
            ////2.调用锁定方法lock()
                Lock.lock();
            try {
                {
                    if(ticket>0){
                        System.out.println(Thread.currentThread().getName()+"买票："+ticket);
                        ticket--;
                    }
                    else {
                        break;
                    }
                }
            } finally {
                // //3.调用解锁方法：unlock()
                Lock.unlock();
            }

        }
    }
}

package com.company;
/* * 线程通信的应用：经典例题：生产者/消费者问题
         *
         * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
         * 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员
         * 会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品
         * 了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
         *
         * 分析：
         * 1. 是否是多线程问题？是，生产者线程，消费者线程
         * 2. 是否有共享数据？是，店员（或产品）
         * 3. 如何解决线程的安全问题？同步机制,有三种方法
         * 4. 是否涉及线程的通信？是*/
public class Product {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer p1=new Producer(clerk);
        Consumer c1=new Consumer(clerk);

        p1.start();
        c1.start();
    }
}

//共享数据可以认为是Clerk或者producecount
class Clerk{
    private int producecount=0;

    public synchronized void produceProduct(){
        if(producecount<20)
        {
            producecount++;
            System.out.println(Thread.currentThread().getName()+":生产"+producecount);

            notify();
        }
        else
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void comsumProduct(){
        if(producecount>0)
        {
            producecount--;
            System.out.println(Thread.currentThread().getName()+":消费"+producecount);

            notify();
        }
        else
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

//生产者线程
class  Producer extends  Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始生产产品.....");
        while (true)
        {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

//消费者的线程
class  Consumer extends Thread{
    private  Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始消费产品.....");
        while (true)
        {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.comsumProduct();
        }
    }
}

* 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
* 1. call()可以有返回值的。
* 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

* 创建线程的方式四：使用线程池
*
* 好处：
* 1.提高响应速度（减少了创建新线程的时间）
* 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
* 3.便于线程管理
*      corePoolSize：核心池的大小
*      maximumPoolSize：最大线程数
*      keepAliveTime：线程没有任务时最多保持多长时间后会终止

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

参考

互斥同步

synchronized 和 ReentrantLock。

互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。

互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。

随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。

乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。

锁优化

公平锁/非公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁。

非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。

对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。

独享锁/共享锁

独享锁是指该锁一次只能被一个线程所持有。

共享锁是指该锁可被多个线程所持有。

对于Java ReentrantLock而言，其是独享锁。但是对于Lock的另一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独享锁。

读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。

独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。

对于Synchronized而言，当然是独享锁。

互斥锁/读写锁

上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。

互斥锁在Java中的具体实现就是ReentrantLock

读写锁在Java中的具体实现就是ReadWriteLock

乐观锁/悲观锁

乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。

悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。

乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。

从上面的描述我们可以看出，悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升。

悲观锁在Java中的使用，就是利用各种锁。

乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。

分段锁

分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。

我们以ConcurrentHashMap来说一下分段锁的含义以及设计思想，ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap(JDK7与JDK8中HashMap的实现)的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表;同时又是一个ReentrantLock(Segment继承了ReentrantLock)。

当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。

但是，在统计size的时候，可就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。

分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

偏向锁/轻量级锁/重量级锁

这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。

偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。

轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。

自旋锁

互斥同步进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。

自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。

在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。

锁消除

锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除。

锁消除主要是通过逃逸分析来支持，如果堆上的共享数据不可能逃逸出去被其它线程访问到，那么就可以把它们当成私有数据对待，也就可以将它们的锁进行消除。

锁粗化

如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗。

如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。