多线程基础

最新推荐文章于 2022-12-11 19:54:05 发布

阅读量55

点赞数

分类专栏：多线程

本文链接：https://blog.csdn.net/weixin_52057887/article/details/115546517

版权

多线程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

第一章进程和线程

1.1进程的介绍

是一个程序的运行状态和资源占用（内存，CPU）的描述
进程是程序的一个动态过程,它指的是从代码加载到执行完毕的一个完成过程
进程的特点：
a.独立性：不同的进程之间是独立的，相互之间资源不共享（举例：两个正在上课的教室有各自的财产，相互之间不共享）

b.动态性：进程在系统中不是静止不动的，而是在系统中一直活动的
c.并发性：多个进程可以在单个处理器上同时进行，且互不影响

1.2线程的介绍

是进程的组成部分，一个进程可以有多个线程，每个线程去处理一个特定的子任务
线程的执行是抢占式的，多个线程在同一个进程中可以并发执行，其实就是CPU快速的在不同的线程之间切换，也就是说，当前运行的线程在任何时候都有可能被挂起，以便另外一个线程可以运行

1.3进程和线程的关系以及区别

a.一个程序运行后至少有一个进程
b.一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义的
c.进程间不能共享资源，但线程之间可以
d.系统创建进程需要为该进程重新分配系统资源，而创建线程则容易的多，因此使用线程实现多任务并发比多进程的效率高
e.系统创建进程需要为该进程重新分配系统资源，而创建线程则容易的多，因此使用线程实现多任务并发比多进程的效率高

第二章多线程的实现

2.1继承Thread类

继承自Thread类，Thread类是所有线程类的父类，实现了对线程的抽取和封装
继承Thread类创建并启动多线程的步骤：
a.定义一个类，继承自Thread类，并重写该类的run方法，该run方法的方法体就代表了线程需要完成的任务，因此，run方法的方法体被称为线程执行体
b.创建Thread子类的对象，即创建了子线程c.用线程对象的start方法来启动该线程

public class ThreadUsageDemo01 {

    public static void main(String[] args) {

        //创建线程对象
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        //给线程取名字
        myThread1.setName("线程1");
        myThread2.setName("线程2");

        //启动线程
        myThread1.start();
        myThread2.start();

        //获取当前线程
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());

        //通过构造方法创建线程
        MyThread3 myThread3 = new MyThread3("新线程");
        //启动线程
        myThread3.start();


    }

}

class MyThread extends Thread {

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }

    }

}

//线程类
class MyThread3 extends Thread {
    public MyThread3() {

    }

    public MyThread3(String name) {
        super(name);//调用的父类中的Thread(String name)
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

结果：
在这里插入图片描述
**结论：**每次运行的结果都不一样，因为线程是谁抢占了资源谁就先调用！

案例：模拟售票员售票

public class ThreadTestDemo01 {

    public static void main(String[] args) {


        SellTickets sellTickets1 = new SellTickets();
        SellTickets sellTickets2 = new SellTickets();
        SellTickets sellTickets3 = new SellTickets();
        SellTickets sellTickets4 = new SellTickets();

        sellTickets1.start();
        sellTickets2.start();
        sellTickets3.start();
        sellTickets4.start();
    }

}

/**
 * 模拟车票售票
 */
//线程类
class SellTickets extends Thread{

    public static int count = 100;

    @Override
    public void run() {


        while (count>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            count--;
            System.out.println("线程是"+Thread.currentThread().getName()+"剩余车票是"+count);
        }
    }
}

结果：
在这里插入图片描述

因为线程在竞争的过程中，CPU的切换是非常快的，可能线程1正好执行完count–的时候，线程已经切换到了线程2，此时count–又再执行了一次，导致跳过了一张票没有卖出，或者，当线程1恰好正好将要执行count–但还没执行的时候，线程已经切换到了线程2，此时因为线程1并没有进行count–操作，线程2卖出了重复的同一张票以后，才执行了count–，导致出现了同一张票重复销售的情况。
此时，我们需要引入线程锁的概念，以解决线程的同步问题。

2.2实现Runnable接口

实现Runnable接口创建并启动多线程的步骤：
a.定义一个Runnable接口的实现类，并重写该接口中的run方法，该run方法的方法体同样是该线程的线程执行
体
b.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
c.调用线程对象的start方法来启动该线程

public class ThreadUsageDemo02 {

    public static void main(String[] args) {

        //创建对象
        check check = new check();
        Thread thread = new Thread(check);
        thread.start();

        Thread thread1 = new Thread(check);
        thread1.start();

    }
}


class check implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "ik");
        }
    }
}

结果：
在这里插入图片描述

案例：模拟售票员售票

public class ThreadTextDemo02 {

    static int count = 100;//票数

    static Runnable runnable = new Runnable() {
        @Override
        public void run() {

            while (count > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName() + "售票一张，剩余" + count);
            }
        }

    };

    public static void main(String[] args) {

        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        Thread thread3 = new Thread(runnable);
        Thread thread4 = new Thread(runnable);

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();


    }

}

结果：
在这里插入图片描述

2.3实现Callable接口

public class FutureTaskTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //创建线程对象
        CallableTest callableTest = new CallableTest();

        //通过线程对象创建
        FutureTask<Integer> integerFutureTask = new FutureTask<>(callableTest);

        //启动
        Thread thread = new Thread(integerFutureTask, "线程1");
        thread.start();

        //获取线程运行的值
        Integer integer = integerFutureTask.get();
        System.out.println(integer);

    }
    
}

//线程类
class CallableTest implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            sum += i;
        }

        return sum;
        
    }
}

结果：
在这里插入图片描述

2.4实现方式的比较

实现Runnable接口的方式
a.线程类只是实现了Runnable接口，还可以继承其他类【一个类在实现接口的同时还可以继承另外一个类】
b.可以多个线程共享同一个target对象，所以非常适合多个线程来处理同一份资源的情况
c.弊端：编程稍微复杂，不直观，如果要访问当前线程，必须使用Thread.currentThread()
继承Thread类的方式:
a.编写简单，如果要访问当前线，程除了可以通过Thread.currentThread() 方式之外，还可以使用super关键字
b.弊端：因为线程类已经继承了Thread类，则不能再继承其他类【单继承】

实际上大多数的多线程应用都可以采用实现Runnable接口的方式来实现【推荐使用匿名内部类】

2.5调用start()与run()方法的区别

当调用start()方法时将创建新的线程，并且执行run()方法里的代码，但是如果直接调用start()方法，不会创建新的线程也不会执行调用线程的代码

关注

0
点赞
踩
0

收藏

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

第一章进程和线程1.1进程的介绍是一个程序的运行状态和资源占用（内存，CPU）的描述进程是程序的一个动态过程,它指的是从代码加载到执行完毕的一个完成过程进程的特点：a.独立性：不同的进程之间是独立的，相互之间资源不共享（举例：两个正在上课的教室有各自的财产，相互之间不共享）b.动态性：进程在系统中不是静止不动的，而是在系统中一直活动的c.并发性：多个进程可以在单个处理器上同时进行，且互不影响1.2线程的介绍是进程的组成部分，一个进程可以有多个线程，每个线程去处理一个特定的子任
复制链接

扫一扫