Java笔记总结：多线程系列（超详细）

最新推荐文章于 2024-05-20 15:43:48 发布

万能小林子

最新推荐文章于 2024-05-20 15:43:48 发布

阅读量143

点赞数

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

本文链接：https://blog.csdn.net/wang1099970453/article/details/109541302

版权

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

目录：点击直达

概念知识

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

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

实现方式

继承 Thread 类

需要重写run方法，调用start开启

可使用匿名内部类方法简单调用

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            System.out.println(i+"t");
        }
    }
}
public class Demo{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0;i<10;i++){
            System.out.println(i+"m");
        }
    }
}

实现 Runnable 接口

实现Runnable与继承Thread相比有如下优势

通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况
可以避免单继承所带来的局限性
任务与线程是分离的，提高了程序的健壮性
后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

public static void main(String[] args) {
    //1 创建一个任务对象
    MyRunnable r = new MyRunnable();
    //创建一个线程并给他一个任务
    Thread t = new Thread(r);
    //启动线程
    t.start();

    for (int i = 0; i < 10; i++) {
        System.out.println("汗滴禾下土"+i);
    }
}
static class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            System.out.println(i+"m");
        }
    }
}

实现Callable接口

1. 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
    @Override
    public <T> call() throws Exception {
    	return T;
    }
}
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);
3. 通过Thread,启动线程
new Thread(future).start();

Runnable 与 Callable的区别

相同点

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

不同点

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

Callable获取返回值

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

Thread类

无论哪种多线程方式都会用到Thread类，线程可以设置name。

//设置和获取线程名称
Thread.currentThread().getName();//获取当前正在执行的线程对象
Thread.currentThread().setName();
new Thread(new MyRunnable(),"线程名称").start();

线程状态

NEW
尚未启动的线程处于此状态。
RUNNABLE
在Java虚拟机中执行的线程处于此状态。
BLOCKED
被阻塞等待监视器锁定的线程处于此状态。
WAITING
无限期等待另一个线程执行特定操作的线程处于此状态。
TIMED_WAITING
正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
TERMINATED
已退出的线程处于此状态。

线程休眠

Thread类的静态方法sleep,单位为毫秒

使用方法：Thread.sleep(1000);

线程阻塞

所有比较消耗时间的操作，都可以理解为线程的阻塞。比如读取文件的时候，导致线程等待，代码不会往下执行。也称耗时操作。

线程中断

一个线程是一个独立的执行路径，它是否结束应该由其自身决定

早期采用stop()方法，存在安全隐患

应该使用中断标记interrupt()，由程序员指定线程自杀方法。

public static void main(String[] args) {
	//线程中断
	//一个线程是一个独立的执行路径，它是否结束应该由其自身决定
	Thread t1 = new Thread(new MyRunnable());
	t1.start();
	for (int i = 0; i < 5; i++) {
		System.out.println(Thread.currentThread().getName()+":"+i);
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	//给线程t1添加中断标记
	t1.interrupt();
}

static class MyRunnable implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				//e.printStackTrace();
				System.out.println("发现了中断标记，线程自杀");
				return;
			}
		}
	}
}

守护线程

用户线程：当一个进程不包含任何的存活的用户线程时，进程结束。
守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

添加方法：

Thread t1 = new Thread(new MyRunnable()); //设置守护线程 t1.setDaemon(true);

线程安全

多个线程同时操作同一个资源时就有可能出现资源不同步问题。

public class Demo {
    public static void main(String[] args) {
        //线程不安全
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {
            while (count>0){
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("卖票结束,余票："+count);
            }
        }
    }
}

//导致结果出现余票-2情况

线程同步

同步代码块和同步方法都属于隐式锁

Java中隐式锁：synchronized；显式锁：lock

实现的三种方法

同步代码块

需要看同一把锁才能实现同步

static class Ticket implements Runnable{
	//总票数
	private int count = 10;
	private Object o = new Object();
	@Override
	public void run() {
		//Object o = new Object();    //这里不是同一把锁，所以锁不住
		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;
				}
			}
		}
	}
}

同步方法

把代码块抽成一个方法加上synchronized修饰符。

如果同步代码块使用的锁和同步方法一样，那么一个执行时，其他线程都不能执行。（一个锁管两个门）

static class Ticket implements Runnable{
	//总票数
	private int count = 10;
	@Override
	public void run() {

		while (true) {
			boolean flag = sale();
			if(!flag){
				break;
			}
		}
	}
	public synchronized boolean sale(){
		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;
	}
}

显式锁

通过Lock类下的ReentrantLock子类创建显式锁，程序员可以自己控制锁lock()和开锁unlock()。

static class Ticket implements Runnable{
	//总票数
	private int count = 10;
	//参数为true表示公平锁    默认是false 不是公平锁
	private Lock l = new ReentrantLock(true);
	@Override
	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();
		}
	}
}

乐观锁和悲观锁

乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种人各有优缺点，不能不以场景而定说一种人好于另外一种人。

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

两种锁的使用场景

从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

公平锁和非公平锁

公平锁

多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。

优点：所有的线程都能得到资源，不会饿死在队列中。
缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。

非公平锁

多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。

优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
缺点：你们可能也发现了，这样可能导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。

显示锁和隐式锁的区别

一、层面不同

synchronized：Java中的关键字，是由JVM来维护的，是JVM层面的锁。
- synchronized底层是通过monitorenter进行加锁
  底层是通过monitor对象来完成的，其中的wait/notify等方法也是依赖于monitor对象的。并且只有在同步块或同步方法中，JVM才会调用monitory对象的，才可以调用wait/notify等方）
- 通过monitorexit来退出锁
Lock：是JDK5以后才出现的具体的类。使用lock是调用对应的API，是API层面的锁。
- lock是通过调用对应的API方法来获取锁和释放锁的。

二、使用方式不同

synchronized
程序能够自动获取锁和释放锁。Sync是由系统维护的，如果非逻辑问题的话话，不会出现死锁。
Lock
需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。
手动获取锁方法：lock.lock()。释放锁：unlock方法。并且需要配合tyr/finaly语句块来完成。

三、等待是否可中断

synchronized
不可中断，除非抛出异常或者正常运行完成。
Lock
可以中断的。
中断方式：
- 调用设置超时方法tryLock(long timeout ,timeUnit unit)
- 调用lockInterruptibly()放到代码块中，然后调用interrupt()方法可以中断

四、加锁的时候是否可以设置成公平锁

synchronized
只能为非公平锁。
lock：两者都可以的。默认是非公平锁。
在其构造方法的时候可以传入Boolean值。true：公平锁、false：非公平锁

五、锁绑定多个条件来condition

synchronized
不能精确唤醒线程。要么随机唤醒一个线程；要么是唤醒所有等待的线程。
Lock
用来实现分组唤醒需要唤醒的线程，可以精确的唤醒。

六、性能区别

synchronized
托管给JVM执行，Java1.5中，由于需要调用操作接口，可能导致加锁消耗时间过长，与Lock性比性能低。1.6以后，语义定义更加清晰，有适应自旋、锁粗化、锁消除、轻量级锁、偏向锁等，可进行许多优化，性能提高了，与Lock差不多。
Lock
java写的控制锁的代码，性能高。

线程死锁

线程死锁描述的是这样一种情况：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

产生死锁四个条件

互斥条件：该资源任意一个时刻只由一个线程占用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

如何避免

破坏互斥条件 ：这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
破坏请求与保持条件 ：一次性申请所有的资源。
破坏不剥夺条件 ：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
破坏循环等待条件 ：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

public class Demo {
    public static void main(String[] args) {
        //线程死锁
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }

    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
            p.fun();
        }
        public synchronized void fun(){
            System.out.println("罪犯被放了，罪犯也放了人质");
        }
    }
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放了你");
            c.fun();
        }
        public synchronized void fun(){
            System.out.println("警察救了人质，但是罪犯跑了");
        }
    }
}

线程通信

方式一：使用 volatile 关键字

基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候，线程能够感知并执行相应的业务。这也是最简单的一种实现方式。

方式二：使用Object类的wait() 和 notify() 方法

众所周知，Object类提供了线程间通信的方法：wait()、notify()、notifyaAl()，它们是多线程通信的基础，而这种实现方式的思想自然是线程间通信。

注意： wait和 notify必须配合synchronized使用，wait方法释放锁，notify方法不释放锁

public class Demo {
    public static void main(String[] args) {
        //多线程通信    生产者与消费者问题
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }
    //厨师
    static class Cook extends Thread{
        private Food f;

        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if(i%2==0){
                    f.setNameAndTaste("老干妈小米粥","香辣味");
                }else {
                    f.setNameAndTaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务员
    static class Waiter extends Thread{
        private Food f;

        public Waiter(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;
        //true表示可以生产
        boolean flag = true;
        public synchronized void setNameAndTaste(String name,String taste){
            if(flag){
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
        public synchronized void get(){
            if(!flag){
                System.out.println("服务员端走的菜的名称是："+name+",味道是："+taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

万能小林子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java笔记总结：多线程系列（超详细）

目录：点击直达概念知识**进程****线程**实现方式继承 Thread 类实现 Runnable 接口实现Callable接口Runnable 与 Callable的区别相同点不同点Callable获取返回值Thread类线程状态线程休眠线程阻塞线程中断守护线程线程安全线程同步实现的三种方法同步代码块同步方法显式锁乐观锁和悲观锁悲观锁乐观锁两种锁的使用场景公平锁和非公平锁公平锁非公平锁显示锁和隐式锁的区别一、层面不同二、使用方式不同三、等待是否可中断四、加锁的时候是否可以设置成公平锁五、锁绑定多个条件来c
复制链接

扫一扫