有一定基础的JAVA学习笔记_05（多线程技术）

yingzhudashu

已于 2022-02-11 19:32:37 修改

阅读量307

点赞数

分类专栏：有一定基础的JAVA学习笔记文章标签： java 开发语言后端

于 2022-02-11 16:35:17 首次发布

本文链接：https://blog.csdn.net/yingzhudashu/article/details/122882069

版权

有一定基础的JAVA学习笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1、基本概念

程序(Program)：一个静态概念，一般对应于操作系统中的一个可执行文件
进程(Process)：一个动态概念，一般指执行中的程序

进程是程序的一次动态执行过程，占用特定的地址空间
每个进程都是独立的，由cpu、data和code3部分组成
多任务(Multitasking)操作系统将CPU时间动态地划分给每个进程，使操作系统同时执行多个进程，每个进程独立运行。但以进程的观点来看，它会以为自己独占CPU的使用权

一个进程可以产生多个线程，同一进程的多个线程也可以共享此进程的某些资源，又被称为轻量级进程(lightweight process)

一个进程内部的一个执行单元，它是程序中的一个单一的顺序控制流程
一个进程可拥有多个并行的(concurrent)线程
一个进程中的多个线程共享相同的内存单元/内存地址空间，可以访问相同的变量和对象，而且它们从同一堆中分配对象并进行通信、数据交换和同步操作
由于线程间的通信是在同一地址空间上进行的，不需要额外的通信机制，这就使得通信更简便而且信息传递的速度也更快
线程的启动、中断、消亡，消耗的资源非常少

2、线程和进程的区别

线程和进程最根本的区别：进程是资源分配的单位，线程是调度和执行的单位
多进程: 在操作系统中能同时运行多个任务(程序)
多线程: 在同一应用程序中有多个顺序流同时执行
一个没有线程的进程是可以被看作单线程的

3、进程与程序的区别

程序是一组指令集合，是静态实体，而进程是动态实体，有自己的生命周期
一个进程肯定与一个程序相对应，并且只有一个
一个程序可以有多个进程，或者一个进程都没有

4、多线程实现

继承Thread类实现多线程

在Java中负责实现线程功能的类是java.lang.Thread类
可以通过创建Thread的实例来创建新的线程
每个线程都是通过某个Thread对象的run( )方法来完成其操作的，方法run( )称为线程体
通过调用Thread类的start()方法来启动一个线程

public class Test extends Thread {//自定义类继承Thread类
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + ":" + i);//getName()方法返回线程名称
        }
    }

    public static void main(String[] args) {
        Test thread1 = new Test();//创建线程对象
        thread1.start();//启动线程
        Test thread2 = new Test();
        thread2.start();
    }
}

缺点：如果该类已经继承了一个类(如小程序必须继承Applet类)，则无法再继承Thread类

通过Runnable接口实现多线程

在开发中，应用更多的是通过Runnable接口实现多线程

public class Test implements Runnable {//自定义类实现Runnable接口；
    //run()方法里是线程体；
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    public static void main(String[] args) {
        //创建线程对象，把实现了Runnable接口的对象作为参数传入；
        Thread thread1 = new Thread(new Test());
        thread1.start();//启动线程；
        Thread thread2 = new Thread(new Test());
        thread2.start();
    }
}

5、线程状态

新生状态(New)：用new关键字线程对象后，该线程对象就处于新生状态
处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态
就绪状态(Runnable)：处于就绪状态的线程已经具备了运行条件，但是还没有分配CPU，处于“线程就绪队列”，等待系统分配CPU
有4种原因会导致线程进入就绪状态：

新建线程调用start()方法，进入就绪状态;
阻塞线程阻塞解除，进入就绪状态;
运行线程调用yield()方法，直接进入就绪状态;
运行线程JVM将CPU资源从本线程切换到其他线程。

运行状态(Running)：在运行状态的线程执行自己run方法中的代码，直到调用其他方法而终止或等待某资源而阻塞或完成任务而死亡
如果在给定的时间片内没有执行结束，就会被系统给换下来回到就绪状态，也可能由于某些“导致阻塞的事件”而进入阻塞状态
阻塞状态(Blocked)：阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪)
有4种原因会导致阻塞：

执行sleep(int millsecond)方法，使当前线程休眠，进入阻塞状态；
执行wait()方法使当前线程进入阻塞状态，可使用nofity()方法唤醒后进入就绪状态；
线程运行时某个操作阻塞了，只有引起该操作阻塞的原因消失后，线程才进入就绪状态；
join()线程联合：当某个线程等待另一个线程执行结束后，才能继续执行时，使用join()方法。

死亡状态(Terminated)：死亡状态是线程生命周期中的最后一个阶段，进入死亡状态就不能再回到其它状态了
线程死亡的原因有两个：

正常运行的线程完成了它run()方法内的全部工作;
线程被强制终止，如通过执行stop()或destroy()方法来终止一个线程。

6、改变线程状态

终止线程一般不使用JDK提供的stop()/destroy()方法，通常的做法是提供一个boolean型的终止变量，当这个变量置为false，则终止线程的运行

public class Test implements Runnable {
    String name;
    boolean live = true;// 标记变量，表示线程是否可中止；
    public Test(String name) {
        super();
        this.name = name;
    }
    public void run() {
        int i = 0;
        //当live的值是true时，继续线程体；false则结束循环，继而终止线程体；
        while (live) {
            System.out.println(name + i);
            i = i + 1;
        }
    }
    public void terminate(String endName) {
        live = false;
        System.out.println(endName + " stop!");
    }

    public static void main(String[] args) throws InterruptedException {
        Test ttc = new Test("线程A:");
        Thread t1 = new Thread(ttc);// 新生状态
        t1.start();// 就绪状态
        for (int i = 0; i < 500; i++) {
            System.out.println("主线程" + i);
        }
        ttc.terminate("ttc");
    }
}

暂停线程常用的方法有sleep()和yield()方法
sleep()方法：可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态
yield()方法：可以让正在运行的线程直接进入就绪状态，让出CPU的使用权

线程A运行时可以调用线程B的join()方法，让线程B和线程A联合，线程A会等待线程B执行完毕后在继续执行

public class Test {
    public static void main(String[] args) {
        Thread father = new Thread(new FatherThread());
        father.start();
    }
}

class FatherThread implements Runnable {
    public void run() {
        System.out.println("爸爸想抽烟，让儿子去买包红塔山");
        Thread son = new Thread(new SonThread());
        son.start();
        try {
            son.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("爸爸出门去找儿子跑哪去了");
            // 结束JVM。如果是0则表示正常结束；如果是非0则表示非正常结束
            System.exit(1);
        }
        System.out.println("爸爸拿到了烟");
    }
}

class SonThread implements Runnable {
    public void run() {
        System.out.println("儿子出门去买烟,需要10分钟");
        try {
            for (int i = 1; i <= 10; i++) {
                System.out.println("第" + i + "分钟");
                Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("儿子买烟回来了");
    }
}

7、线程常用方法

处于就绪状态的线程，会进入“就绪队列”等待JVM根据优先级来挑选
线程的优先级用数字表示，范围从1到10，每个线程的默认优先级是5

获得或设置线程对象的优先级：int getPriority()和void setPriority(int newPriority)

public class Test {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread(), "t1");
        Thread t2 = new Thread(new MyThread(), "t2");
        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}
class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

注意：优先级低只是获得调度的概率低，并不是绝对先调用优先级高的线程

8、线程同步

处理多线程问题时，会存在多个线程访问同一个对象的情况，并且某些线程还想修改这个对象，这时就需要用到“线程同步”
如果没有线程同步机制，两就可能出现类似“从只有100元的账户，取出两次80元”的情况
线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用
由于可以通过private关键字来保证数据对象只能被方法访问，所以只需针对方法设计一套机制，使用synchronized关键字
synchronized 方法：通过在方法声明中加入 synchronized关键字来声明
```
public  synchronized  void accessVal(int newVal);
```
synchronized方法控制对“对象的类成员变量”的访问：每个对象一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则所属线程阻塞，方法一旦执行就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态
缺陷：若将一个大的方法声明为synchronized 将会大大影响效率
synchronized块：块可以让我们精确地控制到具体的成员变量，缩小同步的范围，提高效率
```
synchronized(syncObject)
　  { 
　　 //允许访问控制的代码 
　  }
```

多线程操作同一个对象的实例(使用线程同步)：

public class Test {
    public static void main(String[] args) {
        Account a1 = new Account(100, "高");
        Drawing draw1 = new Drawing(80, a1);
        Drawing draw2 = new Drawing(80, a1);
        draw1.start(); // ATM取钱
        draw2.start(); // 支付宝取钱
    }
}
//模拟银行账户
class Account {
    int money;
    String aname;
    public Account(int money, String aname) {
        super();
        this.money = money;
        this.aname = aname;
    }
}
//模拟提款操作
class Drawing extends Thread {
    int drawingNum; // 取多少钱
    Account account; // 要取钱的账户
    int expenseTotal; // 总共取的钱数

    public Drawing(int drawingNum, Account account) {
        super();
        this.drawingNum = drawingNum;
        this.account = account;
    }

    @Override
    public void run() {
        draw();
    }

    void draw() {
        synchronized (account) {
            if (account.money - drawingNum < 0) {
                System.out.println(this.getName() + "取款，余额不足！");
                return;
            }
            try {
                Thread.sleep(1000); // 判断完后阻塞。其他线程开始运行。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingNum;
            expenseTotal += drawingNum;
        }
        System.out.println(this.getName() + "--账户余额：" + account.money);
        System.out.println(this.getName() + "--总共取了：" + expenseTotal);
    }
}

9、死锁及解决方案

死锁：多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形

class Lipstick {
    //口红类
}
class Mirror {
    //镜子类
}

class Makeup extends Thread {//化妆类继承了Thread类
    int flag;
    String girl;
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    @Override
    public void run() {
        // TODO Auto-generated method stub
        doMakeup();
    }

    void doMakeup() {
        if (flag == 0) {
            synchronized (lipstick) {//需要得到口红的“锁”；
                System.out.println(girl + "拿着口红！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (mirror) {//需要得到镜子的“锁”；
                    System.out.println(girl + "拿着镜子！");
                }

            }
        } else {
            synchronized (mirror) {
                System.out.println(girl + "拿着镜子！");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick) {
                    System.out.println(girl + "拿着口红！");
                }
            }
        }
    }

}

public class Test {
    public static void main(String[] args) {
        Makeup m1 = new Makeup();//大丫的化妆线程；
        m1.girl = "大丫";
        m1.flag = 0;
        Makeup m2 = new Makeup();//小丫的化妆线程；
        m2.girl = "小丫";
        m2.flag = 1;
        m1.start();
        m2.start();
    }
}

死锁的解决方法：同一个代码块，不要同时持有两个对象锁

class Lipstick {
    //口红类
}
class Mirror {
    //镜子类
}

class Makeup extends Thread {//化妆类继承了Thread类
    int flag;
    String girl;
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    @Override
    public void run() {
        // TODO Auto-generated method stub
        doMakeup();
    }

    void doMakeup() {
        if (flag == 0) {
            synchronized (lipstick) {
                System.out.println(girl + "拿着口红！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            synchronized (mirror) {
                System.out.println(girl + "拿着镜子！");
            }
        } else {
            synchronized (mirror) {
                System.out.println(girl + "拿着镜子！");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (lipstick) {
                System.out.println(girl + "拿着口红！");
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Makeup m1 = new Makeup();// 大丫的化妆线程；
        m1.girl = "大丫";
        m1.flag = 0;
        Makeup m2 = new Makeup();// 小丫的化妆线程；
        m2.girl = "小丫";
        m2.flag = 1;
        m1.start();
        m2.start();
    }
}

10、线程并发协作(生产者/消费者模式)

关于多个线程的并发和协作，需要了解一个重要的多线程并发协作模型“生产者/消费者模式”
生产者：指的是负责生产数据的模块(方法、对象、线程、进程)
消费者：指的是负责处理数据的模块(方法、对象、线程、进程)
缓冲区：消费者不能直接使用生产者的数据，生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据
缓冲区的好处：生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况，同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况，从逻辑上实现了“生产者线程”和“消费者线程”的分离，解决忙闲不均的问题，提高效率

public class Test {
    public static void main(String[] args) {
        SyncStack sStack = new SyncStack();// 定义缓冲区对象；
        Shengchan sc = new Shengchan(sStack);// 定义生产线程；
        Xiaofei xf = new Xiaofei(sStack);// 定义消费线程；
        sc.start();
        xf.start();
    }
}

class Mantou {// 馒头
    int id;

    Mantou(int id) {
        this.id = id;
    }
}

class SyncStack {// 缓冲区(相当于：馒头筐)
    int index = 0;
    Mantou[] ms = new Mantou[10];

    public synchronized void push(Mantou m) {
        while (index == ms.length) {//说明馒头筐满了
            try {
                //wait后，线程会将持有的锁释放，进入阻塞状态；
                //这样其它需要锁的线程就可以获得锁；
                this.wait();
                //这里的含义是执行此方法的线程暂停，进入阻塞状态，
                //等消费者消费了馒头后再生产。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 唤醒在当前对象等待池中等待的第一个线程。
        //notifyAll叫醒所有在当前对象等待池中等待的所有线程。
        this.notify();
        // 如果不唤醒的话。以后这两个线程都会进入等待线程，没有人唤醒。
        ms[index] = m;
        index++;
    }

    public synchronized Mantou pop() {
        while (index == 0) {//如果馒头筐是空的；
            try {
                //如果馒头筐是空的，就暂停此消费线程（因为没什么可消费的嘛）。
                this.wait();                //等生产线程生产完再来消费；
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        index--;
        return ms[index];
    }
}

class Shengchan extends Thread {// 生产者线程
    SyncStack ss = null;

    public Shengchan(SyncStack ss) {
        this.ss = ss;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("生产馒头：" + i);
            Mantou m = new Mantou(i);
            ss.push(m);
        }
    }
}

class Xiaofei extends Thread {// 消费者线程；
    SyncStack ss = null;

    public Xiaofei(SyncStack ss) {
        this.ss = ss;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Mantou m = ss.pop();
            System.out.println("消费馒头：" + i);

        }
    }
}

synchronized不能用来实现不同线程之间的通信，使用java.lang.Object类中的方法
注意以上方法都只能在同步方法或者同步代码块中使用，否则会抛出异常

11、任务定时调度

通过Timer和Timetask，我们可以实现定时启动某个线程

java.util.Timer：它本身就是实现就是一个线程，只是这个线程是用来实现调用其它线程的，类似闹钟的功能，定时或者每隔一定时间触发一次线程

import  java.util.*;

public class Test {
    public static void main(String[] args) {
        Timer t1 = new Timer();//定义计时器；
        MyTask task1 = new MyTask();//定义任务；
        t1.schedule(task1,3000);  //3秒后执行；
    }
}

class MyTask extends TimerTask {//自定义线程类继承TimerTask类；
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("任务1:"+i);
        }
    }
}

java.util.TimerTask：它是一个抽象类，该类实现了Runnable接口，所以该类具备多线程的能力。在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，将需要多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行
在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。如果多个线程之间需要完全独立的话，最好还是一个Timer启动一个TimerTask实现

yingzhudashu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
有一定基础的JAVA学习笔记_05（多线程技术）

目录1、基本概念2、线程和进程的区别3、进程与程序的区别4、多线程实现5、线程状态6、改变线程状态7、线程常用方法8、线程同步9、死锁及解决方案10、线程并发协作(生产者/消费者模式)11、任务定时调度1、基本概念程序(Program)：一个静态概念，一般对应于操作系统中的一个可执行文件进程(Process)：一个动态概念，一般指执行中的程序进程是程序的一次动态执行过程，占用特定的地址空间每个进程都是独立的，由cpu、data和code3部
复制链接

扫一扫