初步了解什么是 “线程”和“线程池”

在之前的学习的程序中，没有跳转语句程序的运行，都是由上到下运行的，要是我们想要同时运行两个语句体，怎么实现？
使用多进程和多线程来实现。

一、进程和线程：

1.1.什么是进程：
“进程”是操作系统的概念，一个独立运行的程序，就是一个“进程”。
1.2.什么是线程：
“线程”是由“进程创建”的，一个进程可以创建任意多的线程，每个线程都包含一些代码。线程中的代码会同主进程或者其他线程“同时运行”。

1.3.什么是多进程：
同一时间段，同时运行多个程序。
1.4.什么是多线程：
一个程序同时启动多个线程，也就是多个代码块同时运行。从而提高程序的运行效率。

二、并发和并行

2.1.什么是并发
多个线程同时访问同一资源
例：你正在吃饭，有人来敲门，你放下饭碗去开门，回来接着吃饭。

2.2.什么是并行
多个线程同时开始运行
例：你正在吃饭，来电话啦，你边吃饭边打电话

三、创建线程类

**

3.1.继承Thread

Thread构造方法：
1).Thread():
2).Thread(String name):使用一个“线程名称”创建一个线程对象；
3).Thread(Runnable r):使用一个Runnable对象创建一个线程对象；
4).Thread(Runnable r,String n):使用一个Runnable和线程名称构造一个线程对象。

Thread的常用方法：
1).public String getName():获取线程名称。
注意：任何一个线程对象都有一个默认名称：Thread-[索引]
2).public void setName(String name):设置线程名。
3).public static Thread currentThread():获取当前的线程对象；
4).public static void sleep(long m):让当前的线程对象休息m毫秒；

注：可以通过API进行查询

3.1.1.步骤：

1. 定义线程类，继承Thread
2. 重写run（）方法；
3. 启动线程：
   1）创建一个线程对象
   2）调用对象的start（）方法启动线程

3.1.2.示例代码：
线程类

public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(“从网络接收外部数据…”);

    }
}
}

启动线程：
public static void main(String[] args) {
//先启动线程
MyThread t = new MyThread();
t.start();//启动线程，后，主方法继续向下运行
for (int i = 0; i < 1000; i++) {
System.out.println(“从控制台接收数据…”);
}
}
3.1.3.匿名内部类示例代码
new Thread(){
public void run(){
for (int i = 0; i < 1000; i++) {
System.out.println(“从控制台接收数据…”);

}
}
}.start();
注意：

1. 重写的是run（）方法，启动的是start（）方法。
2. 对于一个“线程对象”，只能调用一次start()，不能多次调用start()；
3. 对于“一个线程类”，可以创建多个线程对象，每个线程对象都可以以独立的线程运行。

3.2.Runnable接口

3.2.1.步骤：

1. 自定义类，实现Runnable接口
2. 重写run（）方法；
3. 启动线程：
   1）创建一个自定义类对象
   2）创建一个Thread对象（Thread是Runnable的子类（可以通过API查询））
   3）调用对象的start（）方法启动线程

3.2.2示例代码：
自定义类，实现接口Runnable
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("i = " + i);
}
}
}
启动线程：
public static void main(String[] args) {
//1.创建自定义类对象
MyRunnable myRun = new MyRunnable();

    //2.创建一个Thread对象
    Thread t1 = new Thread(myRun);
    Thread t2 = new Thread(myRun);
    Thread t3 = new Thread(myRun);
    t1.start();
    t2.start();
    t3.start();
    for (int k = 0; k < 100; k++) {
        System.out.println("k = " + k);

    }
}

3.2.3匿名内部类：
Runnable的匿名子类：
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("i = " + i);
}
}
}).start();

注意：
1).自定义类实现了Runnable接口，并没有继承自Thread，所以不是一个“线程”。
2).这种方式仍然需要Thread。
3).可以将一个自定义类的对象，传给多个Thread。

继承和接口两种方式的区别：

1. 继承只能 ”单继承“
2. 接口能同时实现多个接口

四、线程的安全

4.1.1.当多线程共同访问同一共享资源时，就会产生：安全性问题
示例代码：
public class Ticket implements Runnable {
private int ticket = 100;
@Override
public void run() {
//每个窗口卖票的操作
while (true) {
if (ticket > 0) {//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name + “正在卖:” + ticket‐‐);
}
}
}
}
测试类：
public static void main(String[] args) {
//创建线程任务对象
Ticket ticket = new Ticket();
//创建三个窗口对象
Thread t1 = new Thread(ticket, “窗口1”);
Thread t2 = new Thread(ticket, “窗口2”);
Thread t3 = new Thread(ticket, “窗口3”);
//同时卖票
t1.start();
t2.start();
t3.start();
}
结果：

4.1.2.同步代码块
同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式:
synchronized(同步锁){
需要同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象 可以是任意类型。
2. 多个线程对象 要使用同一把锁。

**注意:**在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

示例代码：
public class Ticket implements Runnable{
private int ticket = 100;
Object lock = new Object();

@Override
public void run() {
//每个窗口卖票的操作
while(true){
synchronized (lock) {
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+“正在卖:”+ticket‐‐);
}
}
}
}
4.1.3.同步方法
**同步方法:**使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
格式：
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)

示例代码：
public class Ticket implements Runnable{
private int ticket = 100;

@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while(true){
sellTicket();
}
}
public synchronized void sellTicket(){
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+“正在卖:”+ticket‐‐);
}
}
}

4.1.4.Lock锁
java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，有加锁与释放锁
public void lock() :加同步锁。
public void unlock() :释放同步锁。

示例代码：
public class Ticket implements Runnable{
private int ticket = 100;
Lock lock = new ReentrantLock();

@Override
public void run() {
//每个窗口卖票的操作
while(true){
lock.lock(); //上锁
if(ticket>0){//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name+“正在卖:”+ticket‐‐);
}
lock.unlock(); //解锁
}
}
}

4.2.1.线程的状态
1).新建：MyThread t = new MyThread();
2).可运行(待运行)：t.start();
3).锁阻塞：运行后调用某个方法，但此方法已被其他线程“锁上了”。
4).无限等待：运行后，调用了“锁的wait()”方法。
5).计时等待：运行后，被调用了sleep(…)；
6).被终止：run()方法正常运行完毕。

4.2.2.线程间通信
当一个工作需要多个线程同时配合完成，这样就需要多个线程之间进行“通信”，以保证这个工作能 够完整的完成。这种相互配合的方式：线程间通信。

4.2.3等待与唤醒机制
1)."等待与唤醒机制”就是“线程间通信”的一种体现。
2).工作形式：
一个线程做一些“准备性工作”。
另一个线程做正常的工作。
由于两个线程是“无序的”，很有可能“第二个线程工作时，第一个线程的准备工作还没有做好，这时就需要第二个线程要主动“等待”，然后第一个线程进入开始做准备，准备工作做好后，再唤醒第二个线程开始正常工作。

五、线程池

5.1.1.线程池思想概述
1).什么是“线程池”：存储了若干多的“线程对象”的一个“容器”。
2).对于一个线程对象“只能启动一次”，若想第二次再用，就需要再次创建一个线程对象，但如果创建 线程对象很耗时，这样如果程序中要反复的使用同一个线程，整个程序的效率就会很低。
3).线程池的思想：在程序启动时，会先创建若干多的线程对象，并存储到一个容器中，作为“线程池”。如果有需要时，取出一个线程对象，并执行它。执行完毕，线程池会回收这个线程对象，如果再次需要，可以再次取出，并执行它。所以，线程池中的线程对象是“可以反复重用”的。这样就避免的反复的创建线程对象，从而提高程序的执行效率。

5.1.2.线程池的概念
线程池类：ExecutorService 这个线程池就可以缓存大量的线程对象，并可以反复的重用它们。

5.1.3.示例代码
public static void main(String[] args) {
//使用线程池
//创建线程池对象
ExecutorService service = Executors.newFixedThreadPool(2);
//创建线程对象
MyThread t = new MyThread();//5秒

//第一次执行此线程--交给"线程池”去执行，线程池执行后，会将此线程对象"缓存"，可以重用
service.submit(t);

//第二次执行此线程
service.submit(t);

//第三次执行此线程
service.submit(t);

//.....

//关闭线程池
service.shutdown();

}