JAVA多线程笔记

最新推荐文章于 2024-08-03 21:02:21 发布

Guangshan Hu

最新推荐文章于 2024-08-03 21:02:21 发布

阅读量557

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/xhy1996/article/details/123503491

版权

Callable(带返回值的线程创建方式)

Runnable 与 Callable的相同点：

Runnable 与 Callable的不同点

Callable获取返回值

线程池

线程池的好处

Java中的四种线程池 ExecutorService

线程与进程

进程：指一个内存中运行的应用程序(每个进程都有一个独立的内存空间)
线程：指进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行.
一个进程最少有一个线程线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

同步与异步

同步 : 排队执行 , 效率低但是安全.
异步 : 同时执行 , 效率高但是数据不安全.
例：数据库事务

并发与并行

并发:指两个或多个事件在同一个时间段内发生。
并行:指两个或多个事件在同一时刻发生(同时发生)。

多线程的实现

特点

1. 通过创建任何和线程分匹配的方式来实现多线程更适合多个线程同时执行相同任务的情况
2. 可以避免单继承extends所带来的局限性(可以多实现implements) 
3. 任务与线程本身是分离的，提高了程序的健壮性
4. 线程池技术，接受Runnable类型的任务，不接受Thread任务

测试类：

package com.test;

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        //线程1：打印5个0
        // 通过Thread
        MyThread m = new MyThread();
        m.start();
        //线程2：打印5个1
        for(int i = 0; i < 5; i++){
            System.out.println(0);
            //指定休眠1000毫秒(1秒） - 执行到这就停1秒
            Thread.sleep(1000);
        }
        //线程3: 打印5个2
        //通过Runnable
        //创建任务对象
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
        //0，1，2是交叉的，三个线程是同时执行的
        /*
        Thread t1 = new Thread(new MyRunnable());
        //设置t1位守护线程：当最后一个用户线程结束时，守护线程自动死亡
        ti.setDaemon(true);
        t1.start();
         */
    }
}

Extends Thread实现多线程：

package com.test;

//实现多线程extends Thread
public class MyThread extends Thread {
    public void run(){
        //这里的代码是一条新的执行路径(线程)
        //通过start()来启动任务，而不是调用run方法
        for(int i = 0; i < 5; i++){
            System.out.println(1);
        }
    }
}

Runnable 实现多线程：

package com.test;

public class MyRunnable implements Runnable{
    public void run(){
        for(int i = 0; i < 5; i++){
            System.out.println(2);
        }
    }
}

线程安全

线程安全例子：卖票
多线程同时操作，会导致票超卖（会出现余票为负数）

package com.test;

 public class RunnableSafeTest{
     public static void main(String[] args) {
         Ticket r = new Ticket();
         Thread t1 = new Thread(r);
         t1.start();
         Thread t2 = new Thread(r);
         t2.start();
         Thread t3 = new Thread(r);
         t3.start();
     }
     static class Ticket implements Runnable{
         private int count = 10;
         public void run(){
             while(count>0){
                 System.out.println("售票...");
                 try{
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 count--;
                 System.out.println("出票成功,余票："+count);
             }
         }
     }
 }

解决方案

解决方案
* 1.同步代码块
* 格式：synchronized(锁对象){
* }
* 2.同步方法
* public synchronized boolean sale(){
* }
* 1,2都是隐式锁
* 3. 显示锁Lock
* lock/unlock

1.同步代码块

package com.test;

/**
 * 1.同步代码块
 * 格式：synchronized(锁对象)
 */
public class RunnableSafeTest1{
    public static void main(String[] args) {
        Ticket r = new Ticket();
        Thread t1 = new Thread(r);
        t1.start();
        Thread t2 = new Thread(r);
        t2.start();
        Thread t3 = new Thread(r);
        t3.start();
    }
    static class Ticket implements Runnable{
        private int count = 10;
        //添加一个锁对象
        private Object o = new Object();
        public void run(){
                while(true){
                    //线程排队
                    synchronized (o){
                        if (count>0){
                        System.out.println("售票...");
                        try{
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        //查看是哪个线程执行的
                        System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                    }else{
                            break;
                        }
                }
            }
        }
    }
}

2.同步方法

package com.test;

/**
 * 2.同步方法
 * 在实现方法时排队执行
 */
public class RunnableSafeTest2{
    public static void main(String[] args) {
        Ticket r = new Ticket();
        Thread t1 = new Thread(r);
        t1.start();
        Thread t2 = new Thread(r);
        t2.start();
        Thread t3 = new Thread(r);
        t3.start();
    }
    static class Ticket implements Runnable{
        private int count = 10;
        //添加一个锁对象
        public void run(){
            while(true){
                //线程排队
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        //在实现sale方法时排队执行
        public synchronized boolean sale(){
            //静态锁对象this
            //非静态锁对象Ticket.class
            if (count>0){
                System.out.println("售票...");
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                //查看是哪个线程执行的
                System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                return true;
            }
            return false;
        }
    }
}

3.显示锁lock

package com.test;

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

/**
 * 3.显式锁（更能提现JAVA面向对象的特点）
 */
public class RunnableSafeTest3{
    public static void main(String[] args) {
        Ticket r = new Ticket();
        Thread t1 = new Thread(r);
        t1.start();
        Thread t2 = new Thread(r);
        t2.start();
        Thread t3 = new Thread(r);
        t3.start();
    }
    static class Ticket implements Runnable{
        private int count = 10;
        //添加一个锁
        Lock l = new ReentrantLock();
        public void run(){
            while(true){
                //锁住
                l.lock();
                if (count>0){
                    System.out.println("售票...");
                    try{
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    //查看是哪个线程执行的
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                }else{
                    break;
                }
                //解锁
                l.unlock();
            }
        }
    }
}

公平锁和非公平锁

公平锁：线程排队，谁先来谁就得到这个锁

非公平锁：无序的，所有线程随机得到锁

实现方式：在显式锁LOCK的基础上

将 Lock l = new Lock()

改为Lock l = new ReentrantLock(fair: true)

fair参数为true就表示公平锁，反之则为不公平锁

Callable(带返回值的线程创建方式)

Runnable 与 Callable的相同点：

都是接口都可以编写多线程程序都采用Thread.start()启动线程

Runnable 与 Callable的不同点

Runnable没有返回值;Callable可以返回执行结果
Callable接口的call()允许抛出异常;Runnable的run()不能抛出

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞

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

/**
 * 带返回值的线程Callable（用的很少，仅了解）
 */
public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> c = new MyCallable();
        //创建FutureTask对象 , 并传入第一步编写的Callable类对象
        FutureTask<Integer> task = new FutureTask<>(c);
        //通过Thread,启动线程
        new Thread(task).start();
        //获取返回值
        Integer j = task.get();
        System.out.println("返回值为："+j);
        //上方线程结束后再执行此线程
        for(int i = 0; i < 5; i++){
            try{
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
    //编写类实现Callable接口 , 实现call方法
    static class MyCallable implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {

            for(int i = 0; i < 5; i++){
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(i);
            }
            return 100;
        }
    }
}

线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。