Java复习线程

最新推荐文章于 2022-01-23 00:41:35 发布

incrediblel

最新推荐文章于 2022-01-23 00:41:35 发布

阅读量196

点赞数

分类专栏： Java复习文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_43888922/article/details/114998669

版权

Java复习专栏收录该内容

1 篇文章 0 订阅

订阅专栏

程序、进程、线程的概念

cpu核数：几核cpu代表同一个瞬时时间能处理的任务数。

主频：进程切换频率

电脑运行速度（几核处理器、主频）

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。

如：运行中的 QQ ，运行中的 MP3 播放器

程序是静态的，进程是动态的

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个程序可同一时间执行多个线程，就是支持多线程的

多线程：一个进程（一个程序运行时），可以分化为并行执行的多个线程（多个子程序）

进程相当于一条河，线程相当于河流的分支

何时需要多线程

程序需要同时执行两个或多个任务。

程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

需要一些后台运行的程序时。（因为多线程是进程的支流，当分支之后就各走各的。假设在进程上跑的代码是主程序，其中第三行代码是开启线程的，那么，开启线程之后线程的代码就和主程序并行，他们之间不相干了。）

有一个进程是浏览器，看网页，比如用百度搜索，需要等待百度的都武器通过网络展示搜索的内容，这个过程需要时间，如果网速越慢，时间越长。在等待过程中，这个浏览器一直占用着cpu资源。考虑在浏览器等待相应的时间，先让这个进程占用的cpu干别的事情。等响应回来了，再继续使用。

Java中多线程的创建和启动

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。

Thread类的特性

Ø 每个线程都是通过某个特定 Thread 对象的 run() 方法来完成操作的，经常把 run() 方法的主体称为 线程体

Ø 通过该 Thread 对象的 start() 方法来调用这个线程

构造方法

Ø Thread() ：创建新的 Thread 对象

Ø Thread(String threadname ) ：创建线程并指定线程实例名

Ø Thread(Runnable target) ：指定创建线程的目标对象，它实现了 Runnable 接口中的 run 方法

Ø Thread(Runnable target, String name) ：创建新的 Thread 对象

继承Thread类与实现Runnable接口

1. 继承 Thread 类

1) 定义子类继承Thread类。

2) 子类中重写Thread类中的run方法。

3) 创建Thread子类对象，即创建了线程对象。

4) 调用线程对象start方法：启动线程，调用run方法。

下面的代码还体现了多线程的异步性（不是从上到下执行，没有先后关系）

package day15;

public class Test
{
    public static void main(String args[])
    {
        Thread t0=new TestThread();
        t0.start();//启动线程，开始运行run方法的东西
        Thread t1=new TestThread();
        t1.start();//启动线程，开始运行run方法的东西
        System.out.println("-----------------------");
        System.out.println("-----------------------");
        System.out.println("-----------------------");
/**
 * 多次运行这个main方法
 * 我们发现main方法中打印的3行与开启线程运行run方法中的打印语句是混合起来的，而且打印顺序不固定，因为相当于开启了一个支流，互不影响
 */
    }
}

package day15;
/**
 * 继承Thread类的方式实现多线程
 */
public class TestThread extends Thread {
    @Override
    public void run() {
        System.out.println("多线程运行的代码");
        for(int i=0;i<5;i++)
        {
            System.out.println("这是多线程的逻辑代码"+i);
        }
    }
}

. 2.实现Runnable接口

1）定义子类，实现Runnable接口。

2）子类中重写Runnable接口中的run方法。

3）通过Thread类含参构造器创建线程对象。

4）将Runnable接口的子类对象作为实际参数传递给

Thread类的构造方法中。

5）调用Thread类的start方法：开启线程，调用

Runnable子类接口的run方法。（两种实例化方法）

package day15;

public class Test
{
    public static void main(String args[])
    {
//        Thread t0=new TestThread();
//        t0.start();//启动线程，开始运行run方法的东西
//        Thread t1=new TestThread();
//        t1.start();//启动线程，开始运行run方法的东西

        //Thread t3=new Thread(new TestRunnable());
        //t3.start();

        Thread t4=new Thread(new TestRunnable(),"t-1");
        t4.start();

        System.out.println("-----------------------");
        System.out.println("-----------------------");
        System.out.println("-----------------------");
/**
 * 多次运行这个main方法
 * 我们发现main方法中打印的3行与开启线程运行run方法中的打印语句是混合起来的，而且打印顺序不固定，因为相当于开启了一个支流，互不影响
 */
    }
}

package day15;

/**
 * 通过实现Runnable接口方式实现多线程
 */
public class TestRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"Runnable多线程运行的代码");
        for(int i=0;i<5;i++)
        {
            System.out.println("这是Runnable多线程的逻辑代码"+i);
        }
    }
}

继承方式和实现方式的联系与区别

区别：

继承Thread: 线程代码存放Thread子类run方法中。重写run方法

实现Runnable：线程代码存在接口的子类的run方法。实现run方法

实现接口的好处：

1）避免了单继承的局限性

2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。(下面代码共享count)

package day15;

public class Test
{
    public static void main(String args[])
    {
//        Thread t0=new TestThread();
//        t0.start();//启动线程，开始运行run方法的东西
//        Thread t1=new TestThread();
//        t1.start();//启动线程，开始运行run方法的东西

        //Thread t3=new Thread(new TestRunnable());
        //t3.start();
        Runnable run=new TestRunnable();
        Thread t3=new Thread(run,"t-2");
        t3.start();
        Thread t4=new Thread(run,"t-1");
        t4.start();

        System.out.println("-----------------------");
        System.out.println("-----------------------");
        System.out.println("-----------------------");
/**
 * 多次运行这个main方法
 * 我们发现main方法中打印的3行与开启线程运行run方法中的打印语句是混合起来的，而且打印顺序不固定，因为相当于开启了一个支流，互不影响
 */
    }
}

package day15;

/**
 * 通过实现Runnable接口方式实现多线程
 */
public class TestRunnable implements Runnable {
    int count=0;
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"Runnable多线程运行的代码");
        for(int i=0;i<5;i++)
        {
            count++;
            System.out.println("这是Runnable多线程的逻辑代码"+count);
        }
    }
}

一般使用实现接口方式来实现多线程

使用多线性的好处

• 多线程程序的优点：

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

2. 提高计算机系统 CPU 的利用率

3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

如果在一个方法里有一千行代码，前三百行，中间三百行，最后四百行这三段代码没有因果关系，这种情况我们就可以使用线程处理，把三段代码放到不同的线程中去运行，就可以并行。

Thread类的主要方法

void start(): 启动线程，并执行对象的run()方法

run(): 线程在被调度时执行的操作

String getName(): 返回线程的名称

package day15;

public class Test1 {
    public static void main(String []args)
    {
        TestRun run=new TestRun();
        Thread t0=new Thread(run);
        Thread t1=new Thread(run);
        t0.start();
        t1.start();
        System.out.println(t0.getName());
        System.out.println(t1.getName());
        System.out.println("-----------------------");
        System.out.println("-----------------------");
        System.out.println("-----------------------");
    }
}
/**
*没有初始化名称，会给出默认名称
*/

void setName(String name):设置该线程名称

package day15;

public class Test1 {
    public static void main(String []args)
    {
        TestRun run=new TestRun();
        Thread t0=new Thread(run);
        Thread t1=new Thread(run);
        t0.start();
        t1.start();
        t0.setName("线程T0");
        System.out.println(t0.getName());
        System.out.println(t1.getName());
        System.out.println("-----------------------");
        System.out.println("-----------------------");
        System.out.println("-----------------------");
    }
}

static currentThread(): 返回当前线程

2.线程的调度与设置优先级

线程的优先级控制

Ø MAX_PRIORITY （ 10 ） ;

Ø MIN _PRIORITY （ 1 ） ;

Ø NORM_PRIORITY （ 5 ） ;

u 涉及的方法：

Ø getPriority () ：返回线程优先值

Ø setPriority ( int newPriority ) ：改变线程的优先级

Ø 线程创建时继承父线程的优先级

 /**
         * 线程的优先级就是哪个线程有较大概率被执行，用数字1-10表示，数字越大，优先级越高，初始化为5
         */
        System.out.println("T0的优先级是"+t0.getPriority());

        /**
         * 线程的优先级就是哪个线程有较大概率被执行，用数字1-10表示，数字越大，优先级越高，初始化为5
         */

        t0.setPriority(1);
        System.out.println("T0的优先级是"+t0.getPriority());

static void yield()：线程让步

Ø 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

Ø 若队列中没有同优先级的线程，忽略此方法

 if(i%2==0){
                Thread.yield();//线程让步
            }

join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止

Ø 低优先级的线程也可以获得执行

package day15;

public class Test1 {
    public static void main(String []args)
    {
        TestRun run=new TestRun();
        Thread t0=new Thread(run);
        Thread t1=new Thread(run);
        t0.start();
        t1.start();
        t0.setName("线程T0");
        System.out.println(t0.getName());
        System.out.println(t1.getName());
        /**
         * 线程的优先级就是哪个线程有较大概率被执行，用数字1-10表示，数字越大，优先级越高，初始化为5
         */

        t0.setPriority(1);
        System.out.println("T0的优先级是"+t0.getPriority());
        System.out.println("-----------------------");
        System.out.println("-----------------------");
        try {
            t0.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        /**
         * 专业的说法，阻塞当前的main方法，先不执行分隔符，先执行join进来的线程的代码，然后继续
         */
        System.out.println("-----------------------");
    }
}

t0永远在2，3分隔符之间

static void sleep(long millis)：(指定时间:毫秒)

Ø 令当前活动线程在指定时间段内放弃对 CPU 控制 , 使其他线程有机会被执行 , 时间到后重排队。

Ø 抛出 InterruptedException 异常

try {
            Thread.sleep(1000);//每次睡眠1000ms，当前循环每1000ms执行一次
            t0.join();
        } catch (InterruptedException e) {
            e.printStackTrace();

stop(): 强制线程生命期结束

        t1.stop();

boolean isAlive()：返回boolean，判断线程是否还活着

System.out.println(t1.isAlive());

线程的生命周期

JDK中用Thread.State枚举表示了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

Ø 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态(new)

Ø 就绪： 处于新建状态的线程被 start() 后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件(执行start

Ø 运行： 当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能（run方法代码开始执行

Ø 阻塞： 在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态（类似堵车，run方法代码暂停执行

Ø 死亡： 线程完成了它的全部工作或线程被提前强制性地中止（自然死亡：程序执行完毕或异常强制死亡：.stop 断电杀掉进程

线程的同步与死锁

问题的提出

Ø 多个线程执行的不确定性引起执行结果的不稳定

Ø 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决办法:

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

通过同步锁完成，锁的是一个对象不是一个方法，不同的对象是不同的锁。

静态的方法static加同步锁就是对所有的对象

Java对于多线程的安全问题提供了专业的解决方式：

同步机制

1、synchronized还可以放在方法声明中，表示整个方法

为同步方法。

例如：

public synchronized void show (String name){

….

}

2、synchronized (对象）{

// 需要被同步的代码；

}

package day15;

public class Test2 {
    public static void main(String[] args) {
        //定义账户对象
        Acount a = new Acount();
        Acount a1 = new Acount();

        //多线程对象
        User u_weixin = new User(a, 2000);
        User u_zhifubao = new User(a, 2000);

        Thread weixin = new Thread(u_weixin,"微信");
        Thread zhifubao = new Thread(u_zhifubao,"支付宝");

        weixin.start();
        zhifubao.start();
    }
}

class Acount{
    public static int money = 3000;//全局变量，所有的操作共享这个变量

    /**
     * 提款，判断账户钱够不够
     * 多线程调用这个方法，就有问题，线程共享资源时，一个线程在执行这个方法没有完毕时，另一个线程又开始执行这个方法
     * 解决思路：显然一个线程整体执行完这个方法，另一个线程再执行
     * 通过synchronized同步锁来完成
     * 可以直接在方法上加上synchronized关键字
     * 在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法
     * 不同的对象就是不同的锁，普通方法加synchronized，线程使用不同的此方法的对象，还有共享资源的问题
     *
     * 普通方法加同步锁，锁的当前方法对应的对象，当前的对象的所有加了同步锁的方法是共用一个同步锁
     * @param m
     */
    public synchronized void drawing(int m){
        String name = Thread.currentThread().getName();

        if(money < m){
            System.out.println(name + "操作，账户金额不足：" + money);
        }else{
            System.out.println(name + "操作，账户原有金额：" + money);
            System.out.println(name + "操作，取款金额：" + m);

            System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
            money = money - m;
            System.out.println(name + "操作，取款后的余额：" + money);
        }

    }

    public synchronized void drawing1(int m){
        String name = Thread.currentThread().getName();

        if(money < m){
            System.out.println(name + "操作，账户金额不足：" + money);
        }else{
            System.out.println(name + "操作，账户原有金额：" + money);
            System.out.println(name + "操作，取款金额：" + m);

            System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
            money = money - m;
            System.out.println(name + "操作，取款后的余额：" + money);
        }

    }

    /**
     * 静态的方法加synchronized，对于所有的对象都是使用同一个一个锁
     * @param m
     */
    public static synchronized void drawing2(int m){
        String name = Thread.currentThread().getName();

        if(money < m){
            System.out.println(name + "操作，账户金额不足：" + money);
        }else{
            System.out.println(name + "操作，账户原有金额：" + money);
            System.out.println(name + "操作，取款金额：" + m);

            System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
            money = money - m;
            System.out.println(name + "操作，取款后的余额：" + money);
        }

    }

    /**
     * 对代码块加入同步锁
     * 代码块synchronized(this)，所有当前的对象的synchronized(this)同步的的代码都是使用同一个锁
     * @param m
     */
    public void drawing3(int m){
        synchronized(this){//表示当前的对象的代码块被加了synchronized同步锁
            //用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
            String name = Thread.currentThread().getName();

            if(money < m){
                System.out.println(name + "操作，账户金额不足：" + money);
            }else{
                System.out.println(name + "操作，账户原有金额：" + money);
                System.out.println(name + "操作，取款金额：" + m);

                System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
                money = money - m;
                System.out.println(name + "操作，取款后的余额：" + money);
            }
        }
    }

    public void drawing4(int m){
        synchronized(this){//表示当前的对象的代码块被加了synchronized同步锁
            //用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
            String name = Thread.currentThread().getName();

            if(money < m){
                System.out.println(name + "操作，账户金额不足：" + money);
            }else{
                System.out.println(name + "操作，账户原有金额：" + money);
                System.out.println(name + "操作，取款金额：" + m);

                System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
                money = money - m;
                System.out.println(name + "操作，取款后的余额：" + money);
            }
        }
    }

    /**
     * synchronized修饰代码块，想要根据不同的对象有不同的锁
     * synchronized(a),这个小括号中传入不同的对象就是不同的锁
     * @param m
     */
    public void drawing5(int m,Acount a){
        synchronized(a){//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
            //不同的对象就有不同的同步锁
            String name = Thread.currentThread().getName();

            //如果是微信操作的，先不执行，等支付宝操作，支付宝操作完，微信再继续操作
            if(name.equals("微信")){
                try {
                    a.wait();//当前的线程进入等待的阻塞状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            if(money < m){
                System.out.println(name + "操作，账户金额不足：" + money);
            }else{
                System.out.println(name + "操作，账户原有金额：" + money);
                System.out.println(name + "操作，取款金额：" + m);

                System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
                money = money - m;
                System.out.println(name + "操作，取款后的余额：" + money);
            }

            if(name.equals("支付宝")){
                try {
                    a.notify();//唤醒当前优先级最高的线程，进入就绪状态
//					a.notifyAll();//唤醒当前所有的线程，进入就绪状态
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class User implements Runnable{
    Acount acount;
    int money;
    public User(Acount acount,int money){
        this.acount = acount;
        this.money = money;
    }
    @Override
    public void run() {
//		acount.drawing(money);
//		if(Thread.currentThread().getName().equals("微信")){
			acount.drawing(money);
//			acount.drawing3(money);
//		}else{
			acount.drawing1(money);
//			acount.drawing4(money);
//		}
//		acount.drawing2(money);//调用类的静态方法

//		acount.drawing3(money);

        acount.drawing5(money, acount);
    }

}

线程的死锁：

Ø 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

解决方法

Ø 专门的算法、原则，比如加锁顺序一致

Ø 尽量减少同步资源的定义，尽量避免锁未释放的场景

线程的通信

wait() 与 notify() 和 notifyAll()

Ø wait() ：令当前线程挂起并放弃 CPU 、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问

在当前线程中调用方法：对象名.wait()

使当前线程进入等待（某对象）状态，直到另一线程对该对象发出 notify (或notifyAll) 为止。

在当前线程中调用方法：对象名.notify()

功能：唤醒等待该对象监控权的一个线程。

调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

调用此方法后，当前线程将释放对象监控权，然后进入等待

在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

Ø notify() ：唤醒正在排队等待同步资源的线程中优先级最高者结束等待

Ø notifyAll () ：唤醒正在排队等待资源的所有线程结束等待 .

Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常

生产者消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题：

生产者比消费者快时，消费者会漏掉一些数据没有取到。

消费者比生产者快时，消费者会取相同的数据。

package day15;

/**
 * 生产者与消费者
 * @author lby
 *
 */
public class Test3 {
    public static void main(String[] args) {
        Clerk c = new Clerk();
        //消费时不生产，生产时不消费

        //生产者
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (c) {
                    while(true){//无限循环代表无限的生产次数
                        if(c.productNum == 0){//产品数为0，开始生产
                            System.out.println("产品数为0，开始生产");
                            while(c.productNum < 4){
                                c.productNum++;//增加产品
                                System.out.println("库存：" + c.productNum);
                            }
                            System.out.println("产品数为" + c.productNum + "，结束生产");

                            c.notify();//唤醒消费者线程
                        }else{
                            try {
                                c.wait();//生产者线程等待
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }, "生产者").start();

        //消费者
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (c) {
                    while(true){//无限循环代表无限的消费次数
                        if(c.productNum == 4){//产品数为4，开始消费
                            System.out.println("产品数为4，开始消费");
                            while(c.productNum > 0){
                                c.productNum--;//消费产品
                                System.out.println("库存：" + c.productNum);
                            }
                            System.out.println("产品数为" + c.productNum + "，结束消费");

                            c.notify();//唤醒生产者线程
                        }else{
                            try {
                                c.wait();//消费者线程等待
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }, "消费者").start();

    }
}


class Clerk{
    public static int productNum = 0;
}

incrediblel

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java复习线程

程序、进程、线程的概念cpu核数：几核cpu代表同一个瞬时时间能处理的任务数。主频：进程切换频率电脑运行速度（几核处理器、主频）程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。如：运行中的QQ，运行中的MP3播放器程序是静态的，进程是动态的线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径
复制链接

扫一扫