线程基础（学习记录）

线程基础（学习记录）

进程：

1.进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间，当我们使用迅雷，又启动了一个进程，操作系统就会为该进程分配新的内存空间

2.进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：由他自身产生，存在和消亡的过程

什么是线程：

1.线程由进程创建的，是进程的一个实体

2.一个进程可以拥有多个线程

其他相关概念：

1.单线程：同一时刻，只允许执行一个线程

2.多线程：同一时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

3.并发：同一时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发

4.并行：同一时刻，多个任务同时执行。多核cpu可以实现并行

创建线程的两种方式：

在java中线程来使用有两种方法。

1.继承Thread类，重写run方法

2.实现Runnable接口，重写run方法

线程基本使用：

案例1-继承Thread类：

package org.example.threaduse;

import org.xml.sax.helpers.AttributesImpl;

//演示通过继承Thread类创建线程
public class Thread01 {
    public static void main(String[] args) {
//        创建Cat对象，可以当作线程使用
        while (true){
            Cat1 cat1 = new Cat1();
            /*
            * 追源码
            *  public synchronized void start() {
            *   start0();
            * }
            * start0()是个本地方法，是JVM调用，底层是c/c++实现
            * 真正实现多线程的效果，是start0(),而不是run
            * */
            cat1.start();//启动线程-》执行cat的run方法，这里为什么不用run方法，因为run只是一个普通的方法，在这儿调用run方法其实就相当于
//            调用的是主线程，而没有新建一个线程出来，相当于加入进了主线程
//            说明：当main线程启动一个子线程 Thread-0,主线程不会阻塞，会继续执行
        }

    }
}

//1.当一个类继承了Thread类，那么这个类就是一个线程了
//2.我们会重写run方法，写上自己的业务代码
//3.Thread中的run实现了Runnable接口的run方法
/*
* @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

* */
class Cat1 extends Thread{
    @Override
    public void run() {
        //该线程每隔一秒，在控制台输出“喵喵，我是小猫咪”
        System.out.println("喵喵，我是小猫咪");
        //让该线程休眠1秒  ctrl+alt+t
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

案例2-实现Runnable接口：

说明：

1.java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了

2.java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

package org.example.threaduse;




//通过是心啊RUnnable来开发线程
public class Thread02 {
    public static void main(String[] args) {
        Dog1 dog1 = new Dog1();
//        dog1.start();这里不能调用start
//        可以创建Thread对象，把dog对象(实现Runnable),放入了Thread,这里底层使用了代理模式来实现
        /*
        * 代码模拟实现Runnable接口开发线程的机制
        * */
        Thread thread = new Thread(dog1);
        thread.start();
    }
}
//这是模拟的Thread方法，看是如何在实现接口的情况下没有start方法怎么来创建线程
//就是通过TreadProxy来代理这个相当于是Thread方法的实现，在继承Runnable后
//通过一个target属性在调用其中的start方法，再调用start0来创建线程

class TreadProxy implements Runnable{//把TreadProxy类当作Thread来看待

    private Runnable target = null;//属性，类型是Runnable


    @Override
    public void run() {
        if(target!=null){
            target.run();
        }
    }

    public TreadProxy(Runnable target){
        this.target = target;
    }

    public void start(){
        start0();
    }
    public void start0(){
        run();
    }
}
class Dog1 implements Runnable{

    int count = 0;
    @Override
    public void run() {
        while (true){
            System.out.println("小狗汪汪叫"+(++count)+Thread.currentThread().getName());
//            休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==10){
                break;
            }
        }
    }
}

案例3-多线程执行；

package org.example.threaduse;

public class Thread03 {
    public static void main(String[] args) {
        hi hi = new hi();
        Thread thread = new Thread(hi);
        hello hello = new hello();
        Thread thread1 = new Thread(hello);
        thread1.start();
        thread.start();
    }
}

class hello implements Runnable{

    @Override
    public void run() {
        int count = 0;
       while (true){
           System.out.println("helloword"+(++count));
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           if(count==10){
               break;
           }
       }
    }

}

class hi implements Runnable{

    @Override
    public void run() {
        int count = 0;
        while (true){
            System.out.println("hi"+(++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==5){
                break;
            }
        }
    }
}

继承Thread vs 实现Runnable的区别：

1.从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口

2.实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且笔迷拿了单继承的限制

案例：售票问题会出现超卖现象

package org.example.ticket;


/*
* 使用多线程模拟三个窗口同时售票100张
* */
public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();
        SellTicket02 sellTicket02 = new SellTicket02();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();


    }
}
class SellTicket01 extends Thread{

    private static int ticketNum=100;//让三个线程共享一个
    @Override
    public void run() {
        while (true){
            if(ticketNum<=0){
                System.out.println("售票结束");
                break;
            }
//            休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"
            +"剩余票数"+(--ticketNum)
            );
        }
    }
}

class SellTicket02 implements Runnable{

    private int ticketNum=100;//让三个线程共享一个
    @Override
    public void run() {
        while (true){
            if(ticketNum<=0){
                System.out.println("售票结束");
                break;
            }
//            休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"
                    +"剩余票数"+(--ticketNum)
            );
        }
    }
}

线程终止：

说明：

1.当线程完成任务后，会自动退出

2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

案例：

需求：启动一个线程t,要求在main线程中取停止线程t

package org.example.exit;

public class ThreadExit {
    public static void main(String[] args) {
        T t = new T();
        t.start();
//        如果希望主线程能控制t线程终止
//        修改loop
        t.setLoop(false);
    }
}

class T extends Thread{
    int count = 0;
//    设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("运行中、、、、、、、、、、、"+(++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程常用方法：

第一组

1.setName:设置线程名称，使之与参数name相同

2.getName:返回该线程的名称

3.start:使该线程开始执行；java虚拟机底层调用该线程的start()方法

4.run:调用线程对象run方法

5.setPriority:更改线程的优先级

6.getPriority:获取线程的优先级

7.sleep:在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

8.interrupt:中断线程

注意事项和细节：

1.start底层会创建新的线程，调用run,run就是一个简单的方法调用，不会启动新线程

2.线程优先级的范围

3.interrupt,中断线程，但并没有真正的结束线程，所以一般用于中断正在休眠线程

4.sleep:线程的静态方法，使当前线程休眠

第二组

1.yield:线程的礼让，让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功

2.join:线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

用户线程和守护线程：

1.用户线程：也叫工作线程，当线程的任务执行完或通知方式结束

2.守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

3.常见的守护线程：垃圾回收机制

Synchronized

线程同步机制：

1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。

2.也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

同步具体方法-Synchronized

1.同步代码块

synchronized(对象){//得到对象的锁，才能操作同步代码

//需要被同步代码;

}

2.synchronized还可以放在方法声明中，表示整个方法-为同步方法

public synchronized void m(String name){

//需要被同步的代码

}

3.如何理解：就好像某个小伙伴上厕所前先把门关上(上锁)，完事后再出来(解锁)，那么其它小伙伴就可在使用厕所了

案例-解决售票超卖问题

package org.example.ticket;


/*
* 使用多线程模拟三个窗口同时售票100张
* */
public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();
//        SellTicket02 sellTicket02 = new SellTicket02();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();

        SellTicket03 sellTicket02 = new SellTicket03();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();


    }
}
//实现接口方式，使用synchronize实现线程同步
class SellTicket03 implements Runnable{

    private int ticketNum=100;//让三个线程共享一个

    private boolean loop = true;
    public synchronized void sell(){//同步方法，在同一时刻，只能有一个线程来操作sell方法
        if(ticketNum<=0){
            loop = false;
            System.out.println("售票结束");

            return;
        }
//            休眠50毫秒
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"
                +"剩余票数"+(--ticketNum)
        );
    }
    @Override
    public void run() {
        while (loop){
            sell();
        }
    }
}
class SellTicket01 extends Thread{

    private static int ticketNum=100;//让三个线程共享一个
    @Override
    public void run() {
        while (true){
            if(ticketNum<=0){
                System.out.println("售票结束");
                break;
            }
//            休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"
            +"剩余票数"+(--ticketNum)
            );
        }
    }
}

class SellTicket02 implements Runnable{

    private int ticketNum=100;//让三个线程共享一个
    @Override
    public void run() {
        while (true){
            if(ticketNum<=0){
                System.out.println("售票结束");
                break;
            }
//            休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"
                    +"剩余票数"+(--ticketNum)
            );
        }
    }
}

互斥锁：

基本介绍：

1.java在java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。

2.每个对象都对应于一个可称为"互斥锁"的标记，这个标记用来保证在人艺时刻，只能有一个线程访问该对象。

3.关键字synchronized来与对象的互斥锁练习。当某个对象用synchronized修饰时，表明对象在任一时刻只能由一个线程访问

4.同步的局限性：导致程序的执行效率要降低

5.同步方法(非静态的)的锁可以时this，也可以时其它对象(要求时同一个对象)

6.同步方法(静态的)的锁为当前类本身

注意事项和细节：

1.同步方法如果没有使用static修饰：默认锁对象为this

2.如果方法使用static修饰，默认锁对象：当前类.class

3.实现的落地步骤

需要先分析上锁的代码

选择同步代码块或同步方法

要求多个线程的锁对象为同一个即可

线程的死锁：

基本介绍：

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生

应用案例：

妈妈：你先完成作业，才让你玩手机

小明：你先让我玩手机，我才完成作业

释放锁：

下面操作会释放锁

1.当前线程的同步方法，同步代码块执行结束

案例：上厕所，完事出来

2.当前线程在同步代码块，同步方法中遇到break,return.

案例：没有正常的完事，经理叫他修改bug,不得已出来

3.当前线程在同步代码块，同步方法中出现了未处理的Error或Exceprion,导致异常结束。

案例：没有正常的完事，发现忘带纸，不得已出来

4.当前线程在同步代码块，同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

案列：没有正常完事，觉得需要酝酿下，所以出来等会再进去

下面操作不会释放锁

1.线程执行同步代码块或同步方法时，程序调用Thread.sleep(),Thread.yield()方法暂停当前线程的执行，不会释放锁

案例：上厕所，太困了，在坑位上眯了一会儿

2.线程执行同步代码块时，其它线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁

提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用。

章节作业：

1.

package org.example.homework;

import java.util.Random;
import java.util.Scanner;

public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        Thread thread = new Thread(a);
        thread.start();
        B b = new B(a);//一定要把a传入b才能控制a进程的结束
        Thread thread1 = new Thread(b);
        thread1.start();
    }
}
class A implements Runnable{
    private boolean loop = true;

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        while (loop){
            System.out.println((int)(Math.random()*100+1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class B implements Runnable{
    private A a;
    private Scanner scanner = new Scanner(System.in);
    public B(A a){//构造器中，直接传入A类对象
        this.a=a;
    }

    public B() {
    }

    @Override
    public void run() {
        //接收到用户的输入
       while (true){
           System.out.println("请输入你的指令（Q）退出");
           char key = scanner.next().toUpperCase().charAt(0);
           if(key=='Q'){
               //已通知的方式结束A线程
               a.setLoop(false);
               break;
           }
       }
    }
}

2.

package org.example.homework;

public class Homework02 {
    public static void main(String[] args) {
        Ka ka = new Ka();
        new Thread(ka).start();
        new Thread(ka).start();
    }
}

class Ka implements Runnable{
    private Integer sum = 10000;
    @Override
    public void run() {

           while (true){
               synchronized (this){
                   if(sum<=0){
                       System.out.println("取完了");
                       break;
                   }
               sum-=1000;
               System.out.println("还剩"+sum);

           }
       }
    }
}

}

}

#### 2.

[外链图片转存中...(img-1InMndD8-1716709795224)]

```java
package org.example.homework;

public class Homework02 {
    public static void main(String[] args) {
        Ka ka = new Ka();
        new Thread(ka).start();
        new Thread(ka).start();
    }
}

class Ka implements Runnable{
    private Integer sum = 10000;
    @Override
    public void run() {

           while (true){
               synchronized (this){
                   if(sum<=0){
                       System.out.println("取完了");
                       break;
                   }
               sum-=1000;
               System.out.println("还剩"+sum);

           }
       }
    }
}