20200805（线程）

一.进程

1.程序（Program）

是对数据描述与操作的代码的集合

2.进程（Process）

是程序的一次动态执行过程

3.特点：

1.进程是系统运行程序的基本单位
2.每一个进程都有自己独立的一块内存空间，一组系统资源
3.每一个进程的内部数据和状态完全独立

二.线程

1.含义

线程是进程中执行运算的最小单位，可以完成一个独立任务的顺序控制流程

2.好处

1.充分利用CPU的资源
2.简化编程模型
3.带来良好的用户体验

3.进程和线程的联系与区别

1.一个进程中至少要有一个线程
2.资源分配给进程，同一进程的所有线程共享给进程的所有资源
3.处理机分配给线程，即真正在处理机上运行的是线程

4.线程的步骤

1.定义线程
2.创建线程对象
3.启动线程
4.终止线程

5.创建线程的三种方式

1. 继承Thread类：
   Thread类的常用方法：
   void run（）：执行任务操作的方法
   void start（）：使该线程开始执行
   void sleep（long millis）：在指定的毫秒数内让当前正在执行的线程休眠
   String getName（）：返回该线程的名称
   int getPriority（）：返回线程的优先级
   Thread.State getState():返回该线程
   boolean isAlive（）：测试线程是否处于活动状态
   void join（）：等待该线程终止
   void interrupt（）：中断线程
   void yield（）：暂停正在执行的线程对象，并执行其他线程

注：run（）：线程要执行的操作代码；start（）：启动线程
调用run（）和start（）区别：
调用run（）：只有主线程一条执行路径，主线程执行run（）
调用start（）：多条执行路径，主线程和子线程并行交替执行，子线程执行run（）方法
适合单继承

/**
 * @author Oldhu
 * @date @Date 2020/8/5
 * @des
 */
public class TestThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <=100 ; i++) {
            System.out.print(Thread.currentThread().getName()+":");
            System.out.println(i);
            System.out.println("线程休眠,进入阻塞状态");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        /*TestThread t1=new TestThread();
        t1.setName("线程1");
        TestThread t2=new TestThread();
        t2.setName("线程2");
        //启动线程
        t1.start();
        t2.start();
*/

        TestThread t=new TestThread();
        t.setName("kjsk");
        Thread th1=new Thread(t);
        th1.setName("jsd1");
        Thread th2=new Thread(t);
        th2.setName("dsasa2");
        th1.start();
        th2.start();
    }
}

2.实现Runnable接口：同Thread，但避免单继承的局限性，便于共享资源

/**
 * @author Oldhu
 * @date @Date 2020/8/5
 * @des
 */
public class TestRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <=100 ; i++) {
            System.out.print(Thread.currentThread().getName()+":");
            System.out.println(i);
            System.out.println(Thread.currentThread().getName()+"礼让下");
            Thread.yield();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestRunnable r=new TestRunnable();
        System.out.println("前");
        Thread t1=new Thread(r,"线程1");
        Thread t2=new Thread(r,"线程2");
        System.out.println("1");
        t1.start();
        System.out.println("2");
        t2.start();
    }
}

3.callable接口

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

/**
 * @author Oldhu
 * @date @Date 2020/8/5
 * @des
 */
public class TestCallable implements Callable <Integer>{
    @Override
    public Integer call() throws Exception {

        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+(i+1));
        }
        return 3;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t= new TestCallable();
        FutureTask<Integer> f=new FutureTask<Integer>(t);
        Thread th= new Thread(f);
        th.start();
        Integer a=f.get();
        System.out.println(a);
    }
}

6.线程的状态

新生状态（New Thread）
可运行状态（Runnable):调用start（）方法
阻塞状态（Blocked）：进入一种不可运行的状态，sleep（）
死亡状态（Dead）：run方法执行完毕，stop（）调用或者出现未捕获到的异常

7.线程调度

抢占式调度，实现线程调度的方法
1.join（）方法：使当前线程暂停执行，等待该方法的线程结束后在继续执行本线程；实现子线程执行完后执行主线程之间的数据传递
2.sleep（）方法：让当前线程停止执行毫秒
3.yield（）方法：可让当前线程暂停执行，允许其他线程执行，但该线程仍处于可执行状态，不是阻塞状态；如果没有其他等待的线程，当前线程会马上恢复执行，会运行优先级相同或更高的线程。
注：只是提供一种可能，但是不能保证一定会实现礼让

8.线程同步

当多个线程操作同一共享资源时，将引发数据不安全的问题
synchronized就是为当前的线程声明一把锁

9.线程间通信

线程之间彼此牵制，互相通信
wait（）：挂起当前线程，并释放共享资源的锁
notify（）：在阻塞的线程中选择一个线程解除阻塞，要等到获得锁后才可真正执行。
notifyAll（）：因调用该对象的wait（）而阻塞的所有线程一次性全部解除阻塞