java多线程知识点总结1

1.

并发：指两个或多个事件在同一个时间段内发生（交替执行）

并行：指两个或多个事件在同一时刻发生（同时发生）

进程：指一个内存中运行的应用程序，每个程序都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建运行到消亡的过程（点击应用程序，进入到内存中占用一些内存执行，进入到内存的程序叫进程）

线程：线程是进程中的一个执行单元，负责当前程序的执行，有一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称为多线程程序

例如：

腾讯电脑管家，点击运行，会进入到内存中，这就是一个进程，点击功能（病毒查杀、清理垃圾、电脑加速）执行，就会开启一条应用程序到CPU的执行路径，cpu就可以通过这个路径执行功能，这个路径有一个名字，叫线程

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

2.

线程的调度：

分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间

抢占式调度：优先让优先级高的线程使用CPU，如果现成的优先级相同，那么会随机选择一个（线程的随机性），java就是使用的抢占试调度

3.

主线程：执行主方法的线程

JVM执行main方法，main方法会进入到栈内存，JVM会找操作系统开辟一条main方法通向CPU的执行路径，CPU就可以通过这个路径来执行main方法，而这个路径有一个名字，叫main主线程

单线程程序：java程序中只有一个线程，执行从main方法开始，从上到下依次执行

当异常发生在主线程里面，单线程程序是有弊端的，当发生异常后，影响以后代码的执行

多线程的类java.lang.Thread代表线程，所有线程对象必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程步骤如下：

1定义Thread类的子类，并重写run()方法，该方法的方法体就代表了线程要完成的任务，因此把run()方法称为主方法

2.创建Thread子类的实例，及创建了线程的对象

3调用线程对象的start()方法来启动该线程

创建多线程的第一种方式：定义Thread类的子类，并重写run()方法

多线程原理：

两个线程，一个main线程，一个新线程一起抢夺CPU的执行权，谁抢到了谁执行对应的代码，结果是随机的

4.

Thread类的常用方法：

1.获取线程的名称：getName();

2.获取当前正在执行的线程 static Thread currentThread（），再使用线程中getName()方法获取线程的名称

//获取线程的名称
// String name=getName();
 //System.out.println(name);

 //获取当前正在使用的线程
 Thread t=Thread.currentThread();
 System.out.println(t);
 String name=t.getName();
 System.out.println(name);
 
 //链式编程获取线程的名字，主线程名称
 System.out.println(Thread.currentThread().getName());

5.

设置线程的名称：

1. 使用Thread类中方法setName()
2. MyThread mt=new MyThread();
   //调用start方法开启新线程，执行run方法
   mt.start();
   //设置线程名称
   mt.setName("小强");

2.创建一个带参数的构造方法，参数传递线程的名称，调用父类的带参构造方法，把线程名称传递给父类，让父类Thread给子线程起一个名称

public MyThread(String name){
    super(name);//给线程名称传递给父类，让父类Thread给子类起一个名字
}

6.Thread类的常用方法sleep()  是当前正在执行的线程以指定的毫秒数暂停

Public static void sleep(Long millis):是当前正在执行的线程以指定的毫秒数暂停，毫秒数结束之后，线程继续执行

//使用Thread类的sleep方法让程序睡眠1秒钟，模拟秒表
try {
    Thread.sleep(1000);//1000毫秒=1秒，打印一次
} catch (InterruptedException e) {
    e.printStackTrace();
}

6.

创建多线程的第二种方式：实现Runnable接口

采用java.lang.Runnable也是一种非常建的一种，我们只要重写run方法即可

步骤如下;

1定义Runnable接口的实现类，并重写该接口的run方法，该run方法的方法体同样是该线程的执行体

2创建Runable实现类实例，在创建Thread对象，构造方法传递Runnable接口的实现类对象（并以此实例作为Thread的target来创建Thread对象），该Thread对象才是真正的线程对象

3调用线程对象的start方法启动线程

7.继承Thread类和实现Runnable接口的区别

实现Runnable接口创建多线程程序的好处：

1避免了单继承的局限性

  一个类只能继承一个类（一个人只能有一个亲爹），类继承了Thread就不能继承其他类了

  实现了Runnable接口，还可以继承其他类，实现其他的接口

2增强了程序的扩展性，降低了程序的耦合性

  实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离

  实现类中，重写run方法用来设置线程任务，创建Thread类对象，调用start方法开启新线程

8.

匿名内部类方式实现线程的创建

//定义Thread类
new Thread(){
    //重写ruan方法
    @Override
    public void run() {
        super.run();
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+"黑马");
        }
    }
}.start();

//线程的接口
 Runnable r= new Runnable(){
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+"程序员");
        }
    }
};
new Thread(r).start();
//简化接口的方式
new Thread(new Runnable(){
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+"传智播客");
        }
    }
}).start();

9.

线程安全

单线程是不会出现线程安全问题的

多线程程序没有访问共享数据，不会产生问题

多线程访问共享的数据就会产生线程安全问题

10.

线程同步：

三种方式完成同步：1.同步代码块 2.同步方法 3.锁机制

1同步代码块;

synchronized(同步锁){

  需要同步操作的代码

}

使用所对象，同步锁对象叫同步锁，也叫同步锁，也叫对象监视器

当t0线程获得CPU的执行权执行run方法遇到synchronized代码块这时t0会检查synchronized代码块是否含有锁对象发现有，就会获取到锁对象，进入到同步中执行

当t1线程获得CPU的执行权，执行run方法，遇到synchronized代码块，这时t1会检查synchronized代码块是否有锁对象，发现没有，t1进入到阻塞状态，会一直等待t0线程归还锁对象

总结;同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步

2同步方法

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

格式：

public synchoronized void method(){

  可能会产生线程安全的代码

}

2.同步锁：

对于非static方法，同步锁就是this

对于static方法，我们是用当前方法所在类的字节码对象（类名.class）

//创建一个方法，在run方法中在调用这方法

public synchronized void payTicket(){
    //判断票是否存在
    if(ticket>0){
        //为了提高安全问题出现的次数。让程序睡眠一下
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"---正在卖票"+ticket+"张票");
        ticket--;
    }
}

静态同步方法：

public static /*synchronized*/ void payTicketStatic(){
    //判断票是否存在
    synchronized(RunnableImp.class){
        if(ticket>0){
            //为了提高安全问题出现的次数。让程序睡眠一下
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"---正在卖票"+ticket+"张票");
            ticket--;
        }
    }

1. lock锁

java.util.concurrent.locks.lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作。同步代码块/同步方法具有的功能lock都由，除此之外更强大更体现面向对象

使用步骤：
1.在成员位置创建一个Reentrantlock对象
2.在可能出现安全问题的代码前调用Lock接口中的方法Lock()获取锁
3.在可能出现安全问题的代码后调用Lock接口中方法unLock() 释放锁

public void run() {
    //使用死循环让卖票重复执行
    while(true){
        //2.在可能出现安全问题的代码前调用Lock接口中的方法Lock()获取锁
         L.lock();
            //先判断票是否存在
            if(ticket>0){
                //为了提高安全问题出现的次数。让程序睡眠一下，输出慢一点
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName()+"---正在卖票"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    //3.在可能出现安全问题的代码后调用Lock接口中方法unLock() 释放锁
                    L.unlock();//无论程序是否出现异常，都会把锁释放掉
                }
             }
    }
}

1. 线程的状态：

new new Thread() 新建状态

Runnable 运行状态

Blocked 阻塞状态

TERMINATED死亡状态   程序出现异常

   Timed-waiting休眠状态  调用sleep（Long） 或者wait（Long）， 休眠状态会自己醒

   Waiting无限等待状态  运行中的线程调用wait会进入无限等待状态 调用notify（）才能唤醒

1. Object类中wait带参数方法和notifyAll方法

wait(Long timeout)  在其他线程调用notify方法或notifyAll方法，或者超过指定的时间量前，但至线程等待

notifyAll()  唤醒在此对象监视器上所有等待的线程

进入到TimeWaiting（记时等待）有两种方式
1.使用sleep(Long m)方法，在毫秒值结束之后，线程唤醒进入到Runnable（运行）/Block（阻塞）
2.使用wait(Long m)方法，wait方法如果毫秒值结束之后，还没有notify唤醒，就会自动醒来，线程唤醒进入到Runnable（运行）/Block（阻塞）

唤醒方法：
  void notify()唤醒在此对象监视器上等待的单个线程
  notifyAll()  唤醒在此对象监视器上所有等待的线程

1. 等待唤醒机制

线程通信：多个线程在处理同一个资源，但是处理的动作（线程任务不同）却不相同。

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为统一资源，线程A与线程B处理的动作，一个是生产一个是消费，那么线程A与线程B之间就存在线程通信

为什么要处理线程通信：

多个线程并发执行的，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么线程之间需要一些协调通信，以此来帮助我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：

线程在处理一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量使用或操作，就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效率利用资源，而这种手段即—等待唤醒机制

什么是等待与唤醒机制：

这是多个线程间的一种协作机制，谈到线程我们经常想到的是线程间的竞争，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制，就好比在公司你和同事们，你们可能存在晋升时的竞争，但更多时候你们需要一起合作完成某些任务

就是在一个线程进行了规定的操作之后，就进入等待状态wait，等待其他线程执行完他们的指定代码后再将其唤醒notify，在有多个线程进行等待时，如果需要，可以使用notifyAll来唤醒所有等待的线程

等待唤醒中的方法：

1 wait() 线程不在活动，不在参与调度，进入wait set中，因此不会浪费cpu的资源，也不会去竞争锁了，这时的线程状态Waiting他还等待着别的线程执行notify  在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列（ready queue）

2 notify() 则选取所通知对象的wait set中的一个线程；例如，餐馆有位置后，等待就餐最久的顾客陷入做

3 notifyAll() 释放所通知对象wait set上的全部线程

当通知唤醒后的线程也不会立即恢复执行，因为当初中断的时候已经不在持有锁，如果能获取锁则线程从Waiting（无线等待）状态变成Runnable（运行）转态，否则，从wait set出来，线程从Waiting状态又变成Blockes（阻塞）状态