本文共 5526 字，大约阅读时间需要 18 分钟。

学习目标：

并发是Java学习的重点内容，没有学好多线程不能算是会Java

首先来了解一些进程与线程的概念：

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。讲人话：启动一个QQ.exe就是启动一个进程。

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。讲人话：在QQ里面发一条消息就是启动了一个线程。

一个进程里面可以有多个线程。

线程的几种状态之间的相互转换：

学习内容：

一.创建多线程

1.继承Thread类

//测试类public class test {
       public static void main(String[] args) {
           ThreadTest t1 = new ThreadTest("t1");        t1.start();        ThreadTest t2 = new ThreadTest("t2");        t2.start();    }}//创建一个线程类class ThreadTest extends Thread{
       private String name;    public ThreadTest(String name){
           this.name = name;    }    //重写Thread的run方法    @Override    public void run() {
           System.out.println(name+"启动了一个线程");    }}

2.实现Runnable接口

这是常见的用法

//测试类public class test {
       public static void main(String[] args) {
           Runnabletest r1 = new Runnabletest();        Runnabletest r2 = new Runnabletest();        Thread t1 = new Thread(r1);        Thread t2 = new Thread(r2);        t1.setName("Thread-t1");        t2.setName("Thread-t2");        t1.start();        t2.start();    }}//用实现Runnable的方式创建一个线程类class Runnabletest implements Runnable {
       //必须重写run方法    @Override    public void run() {
           int sum = 0;        for (int i = 10; i < 20; i++) {
               sum += i;        }        System.out.println("线程" + Thread.currentThread().getName() + "  输出：" + sum);    }}

3.实现Callable接口

这种用法多用与线程池相关的操作

//测试类public class test {
       public static void main(String[] args) {
           Callable
   
     c1 = new CallableTest<>();        Callable
    
      c2 = new CallableTest<>();        FutureTask
     
       task1 = new FutureTask
      
       (c1);        FutureTask
       
         task2 = new FutureTask
        
         (c2); Thread t1 = new Thread(task1); Thread t2 = new Thread(task2); t1.setName("Thread-t1"); t2.setName("Thread-t2"); t1.start(); t2.start(); Integer i1 = task1.get(); Integer i2 = task2.get(); System.out.println(t1.getName()+"得到的值为："+i1); System.out.println(t2.getName()+"得到的值为："+i2); }}//用实现Callable接口的方式创建一个线程类class CallableTest
         
           implements Callable { //必须重写call方法 @Override public Integer call() throws Exception { int sum = 0; for (int i = 30; i < 40; i++) { sum += i; } System.out.println(Thread.currentThread().getName()+"运行了"); return sum; }}
         
        
       
      
     
    
   

二.线程类(Thread)的常用方法

三.线程的同步问题

*同步：使用多个线程访问同一资源

1.同步代码块

• synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
• 同步锁:对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
  (1)锁对象 可以是任意类型。
  (2)多个线程对象 要使用同一把锁。

格式：

synchronized(同步锁){	需要同步操作的代码}

3.同步方法

• 同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式：

public synchronized void method(){	可能会产生线程安全问题的代码}

3.锁机制

与synchronized类似的，lock也能够达到同步的效果

1. Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。
2. Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生。
3. synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 所以如果忘记了释放锁，一样会造成死锁。
4. 使用synchronized方式进行线程交互，用到的是同步对象的wait,notify和notifyAll方法。
   Lock也提供了类似的解决办法，首先通过lock对象得到一个Condition对象，然后分别调用这个Condition对象的：await, signal,signalAll 方法。

用法：

public static void main(String[] args) {        Lock lock = new ReentrantLock();        Condition condition = lock.newCondition();                 Thread t1 = new Thread() {            public void run() {                try {                 		//线程启动，试图占有对象                    lock.lock();                    Thread.sleep(5000);                    //临时释放对象，并等待                    condition.await();                  } catch (InterruptedException e) {                    e.printStackTrace();                } finally {                	//释放锁                    lock.unlock();                }            }        };        t1.setName("t1");        t1.start();

四.线程池

每一个线程的启动和结束都是比较消耗时间和占用资源的。

但如果准备一个任务容器，一次性启动10个 消费者线程； 刚开始任务容器是空的，所以线程都wait在上面；直到一个外部线程往这个任务容器中扔了一个“任务”，就会有一个消费者线程被唤醒notify； 这个消费者线程取出“任务”，并且执行这个任务，执行完毕后，继续等待下一次任务的到来； 如果短时间内，有较多的任务加入，那么就会有多个线程被唤醒，去执行这些任务。

在整个过程中，都不需要创建新的线程，而是循环使用这些已经存在的线程。

• java提供自带的线程池，而不需要自己去开发一个自定义线程池了。

线程池类ThreadPoolExecutor在包java.util.concurrent下

ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue
   
    ());
   

• 第一个参数10 表示这个线程池初始化了10个线程在里面工作
• 第二个参数15 表示如果10个线程不够用了，就会自动增加到最多15个线程
• 第三个参数60 结合第四个参数TimeUnit.SECONDS，表示经过60秒，多出来的线程还没有接到活儿，就会回收，最后保持池子里就10个
• 第四个参数TimeUnit.SECONDS 如上
• 第五个参数 new LinkedBlockingQueue() 用来放任务的集合

execute方法用于添加新的任务

学习时间：

4天

学习产出：

https://blog.csdn.net/qq_44876636/article/details/115382363