线程的基础知识

最新推荐文章于 2024-09-05 10:39:00 发布

刘永健#&

最新推荐文章于 2024-09-05 10:39:00 发布

阅读量89

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/weixin_52539336/article/details/118343514

版权

笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

线程

单线程

基本概念

**程序的概念：**静态代码，为了完成某种功能而用计算机语言编写的指令的集合

**进程的概念：**正在运行中的程序，被加载到内存中（资源加载分配的单位）

**线程的概念：**进程可以进一步细化为线程，就是一个具体的执行任务，是操作系统调度的最小单位

**进程和线程的关系：**一个进程至少有一个线程（主线程 main），也可以包含多个线程，

线程依赖于一个进程，进程结束，线程也就结束。

创建线程

创建线程，在线程中可以写一个独立任务的代码

方法一：先创建一个类，继承Thread类，重写其中的run方法

package com.ff.javathread.day1;

public class MyThread  extends  Thread {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyThread"+i);
        }
    }
}

方法二：先创建一个类，实现Runnable接口，重写run方法

package com.ff.javathread.day1.demo1;

public class MyThread implements Runnable{

        //任务
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
           /* try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            System.out.println(Thread.currentThread().getName()+":MyThread"+i);
        }
    }
}

方法二相较于方法一的优点：避免了单继承的局限性，提高了扩展性，可以继承其它的类，实现多个接口

线程的执行

线程启动

package com.ff.javathread.day1.demo1;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //一个时间节点只能有一个任务（线程）执行
        //cpu轮番调度执行线程
        //时间片，按照时间分配；
        // 抢占式，比较优先级的高低，优先级高抢先执行
        MyThread myThread=new MyThread();
      //线程的构造方法（有参）
        Thread t1=new Thread(myThread,"t1");//  新建状态  新建Thread及其子类对象
               t1.start();     //就绪状态  排队等待CPU调度
                    /*运行状态   线程进入CPU
                    失去CPU执行权或者使用Thread.yield（）方法
                    从运行状态直接进入就绪状态，排队等待
                     */
                    /*阻塞状态   退出运行状态。然后重新进入就绪状态排队等待
                    t1.join(3000); 和 Thread.sleep（1000）；*/
                    //结束状态  线程销毁或死亡 stop（）
        Thread t2=new Thread(myThread,"t2");//  新建状态
                t2.start();       //就绪状态
          //设置当前正在执行的t1线程的优先级
                t1.setPriority(1);
        //设置当前正在执行的t2线程的优先级,最高优先级为MAX_PRIORITY=10
        t2.setPriority(Thread.MAX_PRIORITY);

        //取值为5（Thread.NORM_PRIORITY），默认的优先级为5
        Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
            //获得当前正在执行的线程的名字
           System.out.println(Thread.currentThread().getName());
        //获得当前正在执行的线程的优先级
        System.out.println(Thread.currentThread().getPriority());


    }
}

在主线程中创建一个线程，并启动它

启动线程的时候不能调用run方法，因为这样就是普通方法的调用

必须使用start方法调用

线程需要在CPU中运行，被执行。但是一个时间节点只能有一个线程在执行，CPU轮番调度执行线程

线程在CPU中运行的两种方式

方式一：时间片，按照时间片段分配运行时间

方式二：抢占式，每个线程都在抢占CPU的运行，优先级高的先运行

设置优先级 thread.setPriority（10）；

获得优先级 thread.getPriority（10）；

优先级最高级为10，最低为1，默认为5

线程中的方法

Thread.currentThread() ；获得当前线程

Thread.currentThread().getName() ；获得当前线程的名称

Thread.sleep（1000）；让线程休眠，括号内的参数为long类型的毫秒

thread.join（）；表示该线程先执行，其他线程进入阻塞状态

thread.setPriority（10）；设置优先级

thread.getPriority（10）；获得优先级

线程的状态

新建状态 new Thread（）；此时CPU不会执行

就绪状态 start （）；等待CPU加载，并不是立即执行

运行状态线程获得CPU执行权，开始运行

阻塞状态 join（）； sleep（）；

死亡状态任务结束，自动销毁或者死亡 stop（）；

线程的分类

用户线程

守护线程

package com.ff.javathread.day1.demo3;

public class MyThread  extends  Thread {

    @Override
    public void run() {

        for (int i = 0; i < 1000; i++) {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /*阻塞
            if (i%10==0){
                Thread.yield();阻塞
            }*/
            System.out.println("MyThread"+i);
        }
    }
}

package com.ff.javathread.day1.demo3;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        //  myThread.join(5000);
        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);

            MyThread myThread1 = new MyThread();
             myThread1.setDaemon(true);
            myThread1.start();
            //  myThread.join(5000);

        }
    }
}

守护线程是对用户线程进行保护，当最后一个非守护线程结束后，守护线程也会结束

设置守护线程：thread.setDaemon（true）；括号内必须传入true

必须在start启动前设置

多线程

多线程基本概念

多线程：一个进程同时存在多个线程，CPU执行多个任务，提高了程序性能

优点：提高了CPU的利用率，改善了程序结构

缺点：占用内存多

多线程需要协调和管理，需要CPU时间管理跟踪线程（这两个缺点硬件提升可以解决）

最大的缺点在于安全问题，多线程同时对同一资源共享访问存在安全问题；

解决问题的办法:线程同步,也就是添加同步锁

线程同步（并发与并行）

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。

并发就是同一个对象被多个线程同时操作，比如 1张票有100个人去抢

1 synchronized 隐式

确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源。
在Java代码中实现同步：
使用synchronized(同步监视器)关键字同步方法或代码块。
synchronized (同步监视器）{
// 需要被同步的代码；
}
synchronized还可以放在方法声明中，表示整个方法,为同步方法。
例如：
public synchronized void show (String name){
// 需要被同步的代码；
}

同步代码块执行完成后，同步对象（同步锁）会自动释放，不会显现出来

方法1

使用synchronized(同步监视器)关键字同步方法或代码块。

package com.ff.javathread.day2;

public class TicketThread  extends  Thread {

   static int num=10;
  static Object obj=new Object();
    @Override
    public void run() {

            while (true){
                synchronized (obj){
            if (num>0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
       System.out.println(Thread.currentThread().getName()+"已经售出了最后的第"+num+"张票");
                num--;
            }else {
                break;
            }
        }
        }

方法2

synchronized放在方法声明中，表示整个方法,为同步方法。

package com.ff.javathread.day2.demo3;

public class TicketThread implements  Runnable{
   //实现Runnable的好处，当多个线程执行同一个任务时候，因为只创建了一个对象，可以共享同一个属性
    int num=10;

    @Override
    public void run() {
        while(true){
            if (num>0){
                print();
            }else {
                break;
            }
        }
    }
    //synchronized  默认同步对象为this
    public synchronized void print(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (num>0){
            System.out.println(Thread.currentThread().getName()+"已经售出了最后的第"+num+"张票");
            num--;
        }
    }
}

测试

package com.ff.javathread.day2.demo3;

public class Test {
    public static void main(String[] args) {
        //只创建了一个TicketDemo类的对象，所以两个线程共享同一个属性
        TicketThread ticketThread=new TicketThread();
        Thread t1=new Thread(ticketThread,"窗口一");
        Thread t2=new Thread(ticketThread,"窗口二");

              t1.start();
              t2.start();
    }
}

2 Lock（锁）显式

• Lock

• 从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象
来实现同步。同步锁使用Lock对象充当。
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的
工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，
线程开始访问共享资源之前应先获得Lock对象。
• ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存
语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加
锁、释放锁，但是只能对某一段代码加锁

package com.ff.javathread.day2.demo4;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadDemo implements  Runnable{
   int num=10;
   Lock lock=new ReentrantLock();
    @Override
    public void run() {
        try {
            lock.lock();
         while(true){

             if (num>0){
                     Thread.sleep(1000);
                 System.out.println(java.lang.Thread.currentThread().getName()+"已经售出了最后的第"+num+"张票");
                 num--;
             }else {
                 break;
             }
         }
         }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

package com.ff.javathread.day2.demo4;

public class Test {
    public static void main(String[] args) {
        ThreadDemo threadDemo=new ThreadDemo();
        Thread t1=new Thread(threadDemo,"窗口一");
        Thread t2=new Thread(threadDemo,"窗口二");
        t1.start();
        t2.start();
    }
}

多线程同步

多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，
即各线程间要有先来后到；
同步就是排队+锁：
几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；
为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

当线程1拿到同步锁进行访问，线程2就不能访问必须等待，等到线程1结束之后，释放了同步锁，线程2和其他线程才能访问。

案例模拟卖票
两个窗口分别售票,票数为10张

方法1

使用synchronized(同步监视器)关键字同步方法或代码块。

package com.ff.javathread.day2.demo3;

public class TicketThread implements  Runnable{
   //实现Runnable的好处，当多个线程执行同一个任务时候，因为只创建了一个对象，可以共享同一个属性
    int num=10;

    @Override
    public void run() {
        while(true){
            if (num>0){
                print();
            }else {
                break;
            }
        }
    }
    //synchronized  默认同步对象为this
    public synchronized void print(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (num>0){
            System.out.println(Thread.currentThread().getName()+"已经售出了最后的第"+num+"张票");
            num--;
        }
    }
}

方法2

synchronized放在方法声明中，表示整个方法,为同步方法。

package com.ff.javathread.day2.demo3;

public class TicketThread implements  Runnable{
   //实现Runnable的好处，当多个线程执行同一个任务时候，因为只创建了一个对象，可以共享同一个属性
    int num=10;

    @Override
    public void run() {
        while(true){
            if (num>0){
                print();
            }else {
                break;
            }
        }
    }
    //synchronized  默认同步对象为this
    public synchronized void print(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (num>0){
            System.out.println(Thread.currentThread().getName()+"已经售出了最后的第"+num+"张票");
            num--;
        }
    }
}

测试

package com.ff.javathread.day2.demo3;
public class Test {   
public static void main(String[] args) {   
//只创建了一个TicketDemo类的对象，所以两个线程共享同一个属性  
TicketThread ticketThread=new TicketThread();   
Thread t1=new Thread(ticketThread,"窗口一");   
Thread t2=new Thread(ticketThread,"窗口二");   
t1.start();            
t2.start();   
}
}

线程死锁

死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁.
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续.
案例:中国人和美国人吃饭
正常情况:
中国人:两个筷子
美国人:刀和叉

特殊情况:
中国人: 一个筷子一把刀
美国人:一个筷子一把叉

解决方法：设计时考虑清楚锁的顺序，尽量减少嵌套的加锁交互数量。

package com.ff.javathread.day2.demo1;

public class ThreadDeno extends  Thread {

   static int num=10;
  static Object obja=new Object();
  static Object objb=new Object();

  boolean flag;

    public ThreadDeno(boolean flag) {
        this.flag = flag;
    }

    public ThreadDeno() {

    }

    @Override
    //线程死锁
    public void run() {

        if (flag==true){
            synchronized (obja){
            System.out.println("ifobja");
                synchronized (objb){
                    System.out.println("ifobjb");
                }
        }
        }
        else {
            synchronized (obja){
                System.out.println("elseobja");
                synchronized (objb){
                    System.out.println("elseobjb");
                }
            }
            }

package com.ff.javathread.day2.demo1;

public class Test {
    public static void main(String[] args) {
        ThreadDeno ticketThread=new ThreadDeno();

        Thread thread=new Thread(ticketThread);
        thread.start();
    }
}

分别使用继承Thread和实现Runnable两种方式实现

线程通信

两个线程交替打印1-100之间的数字

package com.ff.javathread.day2.demo5;

public class PrintnNumThread  extends  Thread {
    static int num=100;
     static Object obj=new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
                obj.notify();
                if (num>=1){
                    try {
                        Thread.sleep(0);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+num);
                    num--;
                }else {
                    break;
                }
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

测试（无法控制Threa1和Threa2线程进入同步代码的顺序，这是由CPU调度）

package com.ff.javathread.day2.demo5;

public class Test {
    public static void main(String[] args) {
        PrintnNumThread p1=new PrintnNumThread();
        PrintnNumThread p2=new PrintnNumThread();
           p1.setName("Threa1");
           p2.setName("Threa2");
        p1.start();
        p2.start();

    }
}

线程通信是指由多个线程通过消息传递实现相互牵制，相互调度，即就是线程间的相互作用

static Object obi=new Object（）；设置同步监视器

synchronized （obj）{

obj.notify（）；

同步代码块

obj.wait（）；

}

当线程1进入同步代码块的时候，他会拿到同步锁先执行同步代码块，线程2无法进入，当线程1执行结束之后会obj.wait（）；释放同步监视器（同步锁）。然后线程1 就会进入就绪状态，线程2拿到同步锁，线程2进入同步代码块之后先用obj.notify（）；唤醒执行完的线程1，然后才会执行同步代码块。等线程2执行结束之后会用obj.wait（）；释放同步监视器，进入就绪状态。然后线程1和线程2这样循环，起到相互牵制，相互调度的作用。但是，我们无法控制线程1，线程2谁先进入的顺序，这是由CPU调度的。

线程通讯指的是多个线程通过消息传递实现相互牵制，相互调度，即线程间的相互作用。
涉及三个方法：
.wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
.notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，
就唤醒优先级高的那个。
.notifyAll一旦执行此方法，就会唤醒所有被wait的线程。
说明：
.wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。
.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P4f4Qeq7-1624970552923)(D:\非凡英才\笔记\线程状态.png)]

线程通信
经典例题：生产者/消费者问题
生产者(Productor)将产品放在柜台(Counter)，而消费者(Customer)从柜台
处取走产品，生产者一次只能生产固定数量的产品(比如:1），这时柜台中不能
再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来
取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待.

编写添加和取走的方法

package com.ff.javathread.day2.demo6;

public class Counter {
    int num=0;
    public synchronized void add(){
        while (true){
            this.notify();
            if (num<5&&num>=0){
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // this.notify();
                num++;
                System.out.println("生产者线程生产了一个");
            }else {

                break;
            }
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized void sub (){
        while(true){
            notify();
            if (num>0&&num<5){
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
           // notify();
                num--;
                System.out.println("消费者线程消费了一个");
            }else {
                break;
            }
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

创建线程，使用counter对象调用add（）；方法和sub（）；方法

package com.ff.javathread.day2.demo6;

public class CustomerThread extends  Thread{
Counter counter;

    public CustomerThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        counter.sub();
    }
}

package com.ff.javathread.day2.demo6;

public class ProductThread extends Thread {
   Counter counter;

    public ProductThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
       counter.add();
    }
}

新建一个Counter 类型的counter对象，所以counter对象的num属性和资源两个线程共享，

package com.ff.javathread.day2.demo6;

public class Test {
    public static void main(String[] args) {
        Counter c=new Counter();
        ProductThread p=new ProductThread(c);
        CustomerThread cu=new CustomerThread(c);

        p.start();
        cu.start();

    }
}

线程创建的方式

1， extends Thread

2， implement Runnable

3， implement Callable

第三种方式是JDK5以后的新建线程的方式，与其他两种不同的是，第三种方式重写的方法为call（）；方法，而且它可以抛出异常，支持返回泛型的返回值，这是run（）；方法无法达到的。

package com.ff.javathread.day2.demo7;

import java.util.concurrent.Callable;

public class MyThred  implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int num=10;
        for (int i = 0; i <10 ; i++) {
            num+=i;
        }
        return  num;
        //如果没有返回值  return  null;
    }
}

package com.ff.javathread.day2.demo7;

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

public class Test {
    public static void main(String[] args) {
        MyThred m=new MyThred();

        FutureTask<Integer>   futureTask=new FutureTask<Integer>(m);
          Thread t=new Thread(futureTask);
          t.start();
        try {
            //获得返回值的方法 futureTask.get();
            Integer te=futureTask.get();
            System.out.println(te);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

实现Callable接口与使用Runnable相比，Callable功能更强大些.
相比run（）方法，可以有返回值
•方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，获取返回结果
接收任务
FutureTask futureTask = new FutureTask(任务);
创建线程
Thread t = new Thread(futureTask);
t.start();
Integer val = futureTask.get();获得线程call方法的返回值

System.out.println(val);打印输出返回值

ic class Test {
public static void main(String[] args) {
MyThred m=new MyThred();

    FutureTask<Integer>   futureTask=new FutureTask<Integer>(m);
      Thread t=new Thread(futureTask);
      t.start();
    try {
        //获得返回值的方法 futureTask.get();
        Integer te=futureTask.get();
        System.out.println(te);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}

}


 实现Callable接口与使用Runnable相比，Callable功能更强大些.
 相比run（）方法，可以有返回值
•方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，获取返回结果
接收任务
FutureTask<Integer> futureTask = new FutureTask(任务);
创建线程
Thread t = new Thread(futureTask);
t.start();
Integer val = futureTask.get();获得线程call方法的返回值

System.out.println(val);打印输出返回值

刘永健#&

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程的基础知识

线程单线程基本概念**程序的概念：**静态代码，为了完成某种功能而用计算机语言编写的指令的集合**进程的概念：**正在运行中的程序，被加载到内存中（资源加载分配的单位）**线程的概念：**进程可以进一步细化为线程，就是一个具体的执行任务，是操作系统调度的最小单位**进程和线程的关系：**一个进程至少有一个线程（主线程 main），也可以包含多个线程，线程依赖于一个进程，进程结束，线程也就结束。创建线程创建线程，在线程中可以写一个独立任务的代码方法一：先创建一个类，继承Thread类，重
复制链接

扫一扫