一切为了自己，写下自己的线程总结

最新推荐文章于 2022-06-29 10:41:37 发布
最新推荐文章于 2022-06-29 10:41:37 发布
阅读量258 收藏
点赞数
分类专栏： 老K有话说 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44255950/article/details/107203075
版权

only老K，我为自己代言

目录

概述

What is 线程？（有点拉跨这个英语水平）
在这里插入图片描述
进入主题：
面试中，多线程和并发编程已经是必不可少的了，我经常看到此类问题，当时也简单了解过，什么继承Thread类，实现Runnable接口，这些都被说烂了，知道这些当然是远远不够的，于是这几天搜索相关资料恶补了一下，为了方便后期复习，在此做个总结。

继承Thread类

package com.onlyk.domexc.DomeOne;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-21 20:02
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class TestThread {
    public static void main(String[] args) {
        new MyThread().start();
        System.out.println("!!!");
        new Thread(new MyThread()).start();
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        String name="only老K,我为自己代言";
        String[] split = name.split(",");
        for (String s : split) {
            System.out.println(s+"!!");
        }
    }
}

实现Runnable接口

package com.onlyk.domexc.DomeOne;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-21 20:02
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class TestThread {
    public static void main(String[] args) {
//        new MyThread().start();
//        new Thread(new MyThread()).start();
        new MyRunnable().run();
        new Thread(new MyRunnable()).start();
        new Thread(new MyRunnable(),"only老K").start();
    }
}
class MyRunnable implements Runnable {
    @Override
    public void run() {
      String name="only老K,我为自己代言";
        String[] split = name.split(",");
        for (String s : split) {
            System.out.println(s+"@@@");
        }
    }
}

或者使用匿名内部类

package com.onlyk.domexc.DomeOne;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-21 20:02
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class TestThread {
    public static void main(String[] args) {
//        new MyThread().start();
//        new Thread(new MyThread()).start();
//        new MyRunnable().run();
//        new Thread(new MyRunnable()).start();
//        new Thread(new MyRunnable(),"only老K").start();
        //使用匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                String name="匿名内部类的方式，来创实现";
                System.out.println(name);
            }
        }).start();
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        String name="only老K,我为自己代言";
        String[] split = name.split(",");
        for (String s : split) {
            System.out.println(s+"!!");
        }
    }
}
class MyRunnable implements Runnable {
    @Override
    public void run() {
      String name="only老K,我为自己代言";
        String[] split = name.split(",");
        for (String s : split) {
            System.out.println(s+"@@@");
        }
    }
}

通过Lamata表达式

package com.onlyk.domexc.DomeOne;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-21 20:02
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class TestThread {
    public static void main(String[] args) {
//        new MyThread().start();
//        new Thread(new MyThread()).start();
//        new MyRunnable().run();
//        new Thread(new MyRunnable()).start();
//        new Thread(new MyRunnable(),"only老K").start();
        //使用匿名内部类
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                String name="匿名内部类的方式，来创实现";
//                System.out.println(name);
//            }
//        }).start();
        //通过Lamata表达式
        new Thread(()->{
            System.out.println("表达式");
        }).start();
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        String name="only老K,我为自己代言";
        String[] split = name.split(",");
        for (String s : split) {
            System.out.println(s+"!!");
        }
    }
}
class MyRunnable implements Runnable {
    @Override
    public void run() {
      String name="only老K,我为自己代言";
        String[] split = name.split(",");
        for (String s : split) {
            System.out.println(s+"@@@");
        }
    }
}

实现Callable

package com.onlyk.domexc.DomeOne;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-22 20:45
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class TestCallable {
    public static void main(String[] args) throws Exception{
        //创建执行服务
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //提交执行
        Future submit1 = executorService.submit(new MyCallable());
        Future submit2 = executorService.submit(new MyCallable());
        Future submit3 = executorService.submit(new MyCallable());
        //获取返回值
        Object o1 = submit1.get();//这里需要抛出异常，可以进到get方法中看
        Object o2 = submit2.get();
        Object o3 = submit3.get();
        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o3);
        //关闭服务，不然控制台会一直跑
        executorService.shutdown();
    }
}
class MyCallable implements Callable {
    @Override
    public Object call() {
        for (int i = 0; i < 10 ;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        return true;
    }
}

线程状态

在这里插入图片描述

创建状态
所谓的创建状态，也就是我们的new Thread();
就绪状态
所谓的就绪状态，就是我们myThread.start();
运行状态
运行状态就是我们的代码执行。
阻塞状态
当线程等待（wait）、同步(synchronized)、sleep和join的时候
死亡状态
run()结束、main()结束
线程常用方法
setPriority(int new Priority)更改线程的优先级
sleep(long millis)让当前线程进入休眠
join()相当于插队，插入的线程执行结束后，被插队线程继续执行。
yield()线程礼让，暂停当前的线程，并把该线程状态转化为就绪状态
interrupt()中断线程（不建议用）
isAlive()判断线程是否处于存活状态

手写多线程案例

package com.onlyk.domexc.DomeOne;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-22 20:50
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class Dome {
    public static void main(String[] args) {
        DomeRunnable domeRunnable=new DomeRunnable();
        new Thread(domeRunnable,"one").start();
        new Thread(domeRunnable,"two").start();
        new Thread(domeRunnable,"three").start();
    }
}
class DomeRunnable implements Runnable{
    private int num=20;
    private boolean flag=true;
    public void run() {
        while (flag){
            go();
        }
    }
    public void go(){
        if(num <=0){
            flag=false;
            return;
        }
        try {
            Thread.sleep(100);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":"+ num--);
    }
}

看图片，很显然有重复的操作
在这里插入图片描述
正常来说我们要做到的是减到0就不会在减少了。
可以看出，出现了线程安全问题，原因是在对num变为0之前，有多个线程同时进来。
解决办法，可以通过synchronized线程同步，可以使用同步方法和同步代码块进行解决。同步方法，也就是在方法上加一个synchronized关键字。

   public synchronized void run() {
      while (flag){
          go();
      }
    }

随便你怎么刷新都是一样的
在这里插入图片描述

同步代码块锁的是一个对象，即是需要变化的量

package com.onlyk.domexc.DomeOne;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-22 20:50
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class Dome {
    public static void main(String[] args) {
        DomeRunnable domeRunnable=new DomeRunnable();
        new Thread(domeRunnable,"one").start();
        new Thread(domeRunnable,"two").start();
        new Thread(domeRunnable,"three").start();
    }
}
class DomeRunnable implements Runnable{
    MyNum myNum =new MyNum(20);
    private boolean flag=true;
    public synchronized void run() {
        while (flag){
            go();
        }
    }
    public void go(){
        if(myNum.num <=0){
            flag=false;
            return;
        }
        try {
            Thread.sleep(100);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":"+ myNum.num--);
    }
}
class MyNum{
    int num;
    public MyNum(int num){
        this.num=num;
    }
}

死锁

package com.onlyk.domexc.DomeOne;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-22 20:58
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class DomeDIe {
    public static void main(String[] args){
        Only o=new Only();
        King k=new King();
        new Thread(new MyThread(o,k,0)).start();
        new Thread(new MyThread(o,k,1)).start();
    }
}
class Only{}
class King{}
class MyThread implements Runnable{
    private Only o;
    private King k;
    private int cccc;
    public MyThread(Only o,King k,int cccc){
        this.o=o;
        this.k=k;
        this.cccc=cccc;
    }
    public void run() {
        if(cccc == 0){
            synchronized (o){
                System.out.println(Thread.currentThread().getName()+"获取"+o);
                try {
                    Thread.sleep(1000);
                }catch (Exception e){

                }
                synchronized (k) {
                    System.out.println(Thread.currentThread().getName() + "获得" + k);
                }
            }
        }else{
            synchronized (k){
                System.out.println(Thread.currentThread().getName()+"获取"+k);
                try {
                    Thread.sleep(1000);
                }catch (Exception e){

                }
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName() + "获得" + o);
                }
            }
        }
    }
}

一直在运行，占用CPU。导致死锁
在这里插入图片描述

Lock锁

Lock是一个接口，而不是一个关键字，他是一个显示锁，只能锁同步代码块，不能锁方法，可以显示加锁，释放锁，可以指定唤醒某一个线程，Lock锁有一个实现类是ReentrantLock，可重入锁(递归锁)，在这里说一下，所有的锁都是可重入锁，也就是如果我们获得了外面的锁之后，会自动获取里面的锁。
下面代码正常情况下会出现线程安全问题。

package com.onlyk.domexc.DomeOne;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-22 21:03
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class DomeLock {
    public static void main(String[] args){
     LockThread lockThread = new LockThread();
         new Thread(lockThread).start();
         new Thread(lockThread).start();
         new Thread(lockThread).start();
    }
}
class LockThread implements Runnable{
    private int num = 100;
    @Override
    public void run() {
        while (num > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num --);
        }
    }
}

可以通过RenntrantLock进行加锁，显示锁，记得解锁。

package com.onlyk.domexc.DomeOne;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-22 21:03
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class DomeLock {
    public static void main(String[] args){
     LockThread lockThread = new LockThread();
         new Thread(lockThread).start();
         new Thread(lockThread).start();
         new Thread(lockThread).start();
    }
}
class LockThread implements Runnable{
    private int num = 100;
    //定义一个Lock锁
    ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();
            if(num > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num --);
            }else{
                break;
            }
            lock.unlock();
        }
    }
}

比ReentrantLock更细的锁是，ReentrantReadWriteLock，这里有一个读锁，一个写锁，

package com.onlyk.domexc.DomeOne;

import java.util.HashMap;
import java.util.Map;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-29 21:52
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class ReentrantLockDome {
    public static void main(String[] args) {
            MyReadWriteLock myReadWriteLock = new MyReadWriteLock();
            for (int i = 0; i < 5; i++) {
                int temp = i;
                new Thread(()->{
                    myReadWriteLock.put(temp + "",temp + "");
                },""+temp).start();
            }
            for (int i = 0; i < 5; i++) {
                int temp = i;
                new Thread(()->{
                    myReadWriteLock.get(temp + "");
                },temp + "").start();
            }
    }
}
class MyReadWriteLock{
    private volatile Map<String,String> map=new HashMap<String, String>();
    public void put(String key,String value){
        System.out.println(Thread.currentThread().getName()+"写"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入完成");
    }
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读"+key);
        map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取完成");
    }
}

如果不加锁的话，在写入完成之前会被其他线程插入
如图

我们想要的是，在写入的时候，只能是一个线程，而读取的时候，可以是多个线程

package com.onlyk.domexc.DomeOne;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author only老K 我为自己代言
 * @create 2020-06-29 21:52
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class ReentrantLockDome {
    public static void main(String[] args) {
            MyReadWriteLock myReadWriteLock = new MyReadWriteLock();
            for (int i = 0; i < 5; i++) {
                int temp = i;
                new Thread(()->{
                    myReadWriteLock.put(temp + "",temp + "");
                },""+temp).start();
            }
            for (int i = 0; i < 5; i++) {
                int temp = i;
                new Thread(()->{
                    myReadWriteLock.get(temp + "");
                },temp + "").start();
            }
    }
}
class MyReadWriteLock{
    private volatile Map<String,String> map = new HashMap<>();
    ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    public void put(String key,String value) {
        readWriteLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + "写入" + key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + "写入完成");
        readWriteLock.writeLock().unlock();
    }

    public void get(String key) {
        readWriteLock.readLock().lock();
        System.out.println(Thread.currentThread().getName() + "读取" + key);
        map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取完成");
        readWriteLock.readLock().unlock();
    }
}

在这里插入图片描述

synchronized和Lock的区别

  • synchronized是关键字，Lock是类
  • synchronized无法获取锁的状态，Lock可以
  • synchronized会自动释放锁，Lock需要手动
  • synchronized没有Lock锁灵活（Lock锁可以自己定制）

只说理论是不行的，下面说几个ReentrantLock的场景

ReentrantLock默认是非公平锁，但它可以设置公平锁，也就是谁先来的谁先获得锁new ReentrantLock(true)。
ReentrantLock可以响应中断，也就是当两个线程发生死锁的时候，你把A线程中断了，B线程可以正常运行。
ReentrantLock可以通过tryLock()实现限时等待，这样可以解决死锁问题。
synchronized
synchronized在JDK1.6进行了锁的优化，也就是当一个线程多次访问一个同步代码块的时候，此时会记录该线程的threadId也就是，当你再来访问的时候，我就只需判断threadId就行了，效率高，这属于偏向锁。
当有多个线程来的时候，那么这个锁就会升级为轻量级锁，也就是通过CAS，来进行尝试获取锁，是一种自旋锁的状态。如果在短时间内可以获得锁，不会堵塞，而且节约了CUP上下文切换的时间。
如果长时间没有获取到锁，会消耗CUP的资源，因为在那一直死循环，经过一个时间段后会升级为重量级锁，会发生阻塞。其中锁升级是不可逆的。

生产者消费者问题

这是一个经典的线程通信问题，也就是不同线程之间有联系，生产者生产的东西放到缓冲区，如果缓冲区满了，生产者进入堵塞，缓冲区空了，消费者堵塞。
常用的方法有wait()，notify()，notifyAll()

package com.onlyk.domexc.Seven8;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 12:26
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome {
        public static void main(String[] args) {
            Buffer buffer=new Buffer();
            new Thread(()->{
                for (int i = 0; i < 100; i++) {
                    System.out.println("生产者生产了" + i);
                    buffer.put();
                }
            },"生产者").start();
            new Thread(()->{
                for (int i = 0; i < 100; i++) {
                    System.out.println("消费者消费了" + i);
                    buffer.get();
                }
            },"消费者").start();
        }
    }
    //缓冲区
    class Buffer{
        private int len=0;
        public synchronized void put (){
            if (len < 10){
                len++;
            }else{
                try {
                    wait();
                }catch (Exception e){

                }
            }
            notifyAll();
        }
        public synchronized void get() {
            if (len > 0) {
                len --;
            } else {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            notifyAll();
        }
}

其中这里引入了Condition，他可以指定唤醒某个线程，这里我们演示三个线程ABC。

package com.onlyk.domeone.Thread;


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

public class Main {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                buffer.a();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                buffer.b();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                buffer.c();
            }
        },"C").start();
    }
}
// 缓冲区
class Buffer {
    private int flag = 1;// 1执行A，2执行B，3执行C
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();// 该对象可以设置一些条件
    Condition condition2 = lock.newCondition();// 该对象可以设置一些条件
    Condition condition3 = lock.newCondition();// 该对象可以设置一些条件

    public void a() {
        lock.lock();
        try {
            while (flag != 1) {
                condition1.await();
            }
            System.out.println("A");
            flag = 2;
            condition2.signal();// 指定唤醒B
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        lock.lock();
        try {
            while (flag != 2) {
                condition2.await();
            }
            System.out.println("B");
            flag = 3;
            condition3.signal();// 指定唤醒C
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void c() {
        lock.lock();
        try {
            while (flag != 3) {
                condition3.await();
            }
            System.out.println("C");
            flag = 1;
            condition1.signal();// 指定唤醒A
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

八锁问题

一锁

package com.onlyk.domexc.Seven8;

import java.util.concurrent.TimeUnit;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 7:49
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome1 {
    public static void main(String[] args) {
        Man man=new Man();
        new Thread(()->{
            man.go();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            man.in();
        }).start();
    }
}
class Man{
        public synchronized void go(){
            System.out.println("出去");
        }
        public synchronized void in(){
            System.out.println("进来");
        }
}

在这里插入图片描述
先输出出去，不要理解为是先调用了go（），而是因为上面线程先获得了锁。

二锁

class Man{
        public synchronized void go(){
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("出去");
        }
        public synchronized void in(){
            System.out.println("进来");
        }
}

结果还是一样的啊。这里的synchronized锁的对象是调用者，这两个方法用的是同一把锁，谁先拿到，谁先执行

三锁

class Man{
        public synchronized void go(){
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("出去");
        }
        public void in(){
            System.out.println("进来");
        }
}

这里in()方法是没有使用synchronized锁的了，等于就是先输出in()因为他不去获取锁资源，所以直接输出了

四锁

package com.onlyk.domexc.Seven8;

import java.util.concurrent.TimeUnit;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 7:49
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome1 {
    public static void main(String[] args) {
        Man man=new Man();
        Man king=new Man();
        new Thread(()->{
            man.go();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            king.in();
        }).start();
    }
}
class Man{
        public synchronized void go(){
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("出去");
        }
        public synchronized void in(){
            System.out.println("进来");
        }
}

在这里插入图片描述
这里用两个Man对象，分别调用go和in方法，会先执行哪个?因为这里的锁锁的是对象，而他们不是同一个对象，所以资源不受影响。所以先执行in()

五锁

package com.onlyk.domexc.Seven8;

import java.util.concurrent.TimeUnit;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 7:49
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome1 {
    public static void main(String[] args) {
        Man man=new Man();
        new Thread(()->{
            man.go();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            man.in();
        }).start();
    }
}
class Man{
        public static synchronized void go(){
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("出去");
        }
        public static synchronized void in(){
            System.out.println("进来");
        }
}

在这里插入图片描述
这里是通过一个对象，去调用静态的同步方法。这里锁的是Class对象（只有一个）。

六锁

package com.onlyk.domexc.Seven8;

import java.util.concurrent.TimeUnit;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 7:49
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome1 {
    public static void main(String[] args) {
        Man man=new Man();
        Man king=new Man();
        new Thread(()->{
            man.go();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            king.in();
        }).start();
    }
}
class Man{
        public static synchronized void go(){
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("出去");
        }
        public static synchronized void in(){
            System.out.println("进来");
        }
}

这里是通过两个对象去调用go和in，结果是什么呢，答案还是先执行go，因为锁的是Class对象，所以不管是man还是king，都是属于Phone的Class对象。

七锁

package com.onlyk.domexc.Seven8;

import java.util.concurrent.TimeUnit;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 7:49
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome1 {
    public static void main(String[] args) {
        Man man=new Man();
        new Thread(()->{
            man.go();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            man.in();
        }).start();
    }
}
class Man{
        public static synchronized void go(){
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("出去");
        }
        public synchronized void in(){
            System.out.println("进来");
        }
}

在这里插入图片描述
一个是静态同步方法，一个是普通同步方法，用一个对象对调用。静态同步方法锁的是Class对象，而普通同步方法锁的是调用者，锁的不是同一个东西。

八锁

package com.onlyk.domexc.Seven8;

import java.util.concurrent.TimeUnit;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 7:49
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome1 {
    public static void main(String[] args) {
        Man man=new Man();
        Man king=new Man();
        new Thread(()->{
            man.go();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            king.in();
        }).start();
    }
}
class Man{
        public static synchronized void go(){
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("出去");
        }
        public synchronized void in(){
            System.out.println("进来");
        }
}

这里用两个对象去调用静态同步方法go和普通同步方法in，会先输出哪个，答案是in，因为go锁的是Class，而in锁的是调用者，不是同一个一个东西
在这里插入图片描述

线程池

package com.onlyk.domexc.Seven8;

import java.security.Policy;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 9:29
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome2 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(5);// 创建固定个数线程
//        ExecutorService pool1 = Executors.newCachedThreadPool();// 创建动态线程（自适应大小）
//        ExecutorService pool2 = Executors.newSingleThreadExecutor();// 创建单个线程
        pool.execute(new PoolThread());
        pool.execute(new PoolThread());
        pool.execute(new PoolThread());
        // 关闭连接 不关闭连接会一直占用CPU
        pool.shutdown();
    }
}
class PoolThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

在这里插入图片描述
但是按照阿里规范的话就是不推荐我们使用这种
在这里插入图片描述
对于ThreadPoolExecutor的学习，就从七大参数，四种拒绝策略
在这里插入图片描述

int corePoolSize// 核心线程池大小
int maximumPoolSize// 最大核心线程池大小
long keepAliveTime// 超时存活时间
TimeUnit unit//  超时单位
BlockingQueue<Runnable> workQueue// 阻塞队列
ThreadFactory threadFactory// 线程工厂，用于创建线程
RejectedExecutionHandler handler// 拒绝策略

四种拒绝策略：
AbortPolicy());// 银行满了还有人进来，不处理，抛出异常（默认）
CallerRunsPolicy();// 银行满了，不处理，哪里来的去哪里，一般抛给main线程
DiscardPolicy();// 银行满了，把该线程丢掉，不抛异常
DiscardOldestPolicy();// 银行满了，会和先来的线程竞争，不抛异常

package com.onlyk.domexc.Seven8;

import java.util.concurrent.*;

/**
 * @author only老K 我为自己代言
 * @create 2020-07-08 12:14
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class dome3 {
    public static void main(String[] args){
        /**
         * 用一个银行的例子进行讲解这七大参数
         */
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,// 两个常开营业窗口
                5,// 五个窗口，其中三个应急用
                3,// 超时存货时间
                TimeUnit.SECONDS,// 超时时间单位
                new LinkedBlockingDeque<>(3),// 银行候客区大小
                Executors.defaultThreadFactory(),// 默认线程池工厂
                new ThreadPoolExecutor.AbortPolicy());// 银行满了还有人进来，不处理，抛出异常（默认）
        // new ThreadPoolExecutor.CallerRunsPolicy();// 银行满了，不处理，哪里来的去哪里，一般抛给main线程
        // new ThreadPoolExecutor.DiscardPolicy();// 银行满了，把该线程丢掉，不抛异常
        // new ThreadPoolExecutor.DiscardOldestPolicy();// 银行满了，会和先来的线程竞争，不抛异常
        for (int i = 0; i < 8; i++) {
            threadPool.execute(()->{
                System.out.println(Thread.currentThread().getName());
            });
        }
        // 关闭连接
        threadPool.shutdown();
    }
}

end…

only老K
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Win32 多线程学习总结
bcbobo21cn的专栏
04-03 2073
Win32多线程编程学习心得 http://blog.csdn.net/jonathan321/article/details/50782832 博客原文地址：http://jerkwisdom.github.io/study/thread/thread-Summary/ 此处博客不再更新。 为什么多线程？ 多线程并不一定是最好的，合适才是最好的。 多线程主要的优点是价
第三百篇博客：写给自己的总结
BoringError的博客
03-02 3210
这篇博客是这两年来写的第三百篇博客，所以不打算写和技术相关的东西，而是想用来回顾和总结一下这几年来的学习生活历程，回顾几个重要的时间节点。算是一篇写给自己看的总结吧。
总结：协程与线程
w2009211777的专栏
06-29 1万+
线程，协程，进程
C++/C# Thread多线程总结
baidu_38621657的博客
12-19 1564
1.背景 一直都想写一篇关于多线程的文章，总结一下这方面的知识，也为自己和有需要的人提供参考，不再赘述，开始吧， 现在计算机一般都是多核的，4核和8核的比较多件，用于线上计算或专用工作的计算机更是大概率“土豪”级别，如果不充分利用计算机的这一资源，那么将是一种浪费，尤其在现在行业竞争激烈，拼性能 的时代，充分利用有限的计算机资源显得尤为重要，试看一下你用visual studio编译项目时，自己电脑的cpu使用率会多高？没错，接近100%！你所用的开发工具都在充分利用多核资源，节省你开发...
三万字总结Java多线程
weixin_49329785的博客
05-04 5182
JUC简介 在Java中，线程部分是一个重点，本篇文章说的JUC也是关于线程的。JUC就是java.util.concurrent工具包的简称。这是一个处理线程的工具包，JDK1.5开始出现的。 线程与进程 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。---生命周期 进程 — 资源分配的最小单位。 线程(th..
java线程基础知识总结
星晚的博客
03-04 1万+
本期讲解的是java中关于线程的相关知识点1.创建线程的方式2.线程的优先级3.线程阻塞4.线程的相关方法5.守护线程6.线程池7.多线程并发安全问题7.3静态方法修饰synchronized 1.创建线程的方式 1.1继承Thread类并重写run方法 public class ThreadDemo1 { public static void main(String[] args) { MyThread1 t1 = new MyThread1(); MyThread2 t2 = new My
一文掌握 Redis 线程模型
过往记忆大数据
11-30 1502
作者：vivo互联网服务器团队-Wang Shaodong一、概述众所周知，Redis是一个高性能的数据存储框架，在高并发的系统设计中，Redis也是一个比较关键的组件，是我们提升系统性能...
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
进程与线程相关总结
许诗宇的博客
06-10 4100
进程 进程的概念（Dijkstra） 进程是可并发执行的程序在某个数据集合上的一次计算活动，也是操作系统进行资源分配和调度的基本单位。 1 进程是CPU资源分配的最小单位。 2 进程有独立的系统资源。拥有独立的内存单元。 3 一个进程崩溃，不会影响其他进程。 4 进程在创建，切换和销毁时候开销比较大。进程创建的时候需要分配系统资源（ 内存空间，I/O设备 ）。而销毁的时候需要释放系统资源。 5 进程切换 涉及到整个当前进程CPU环境的保存以及新被调度运行的进程的CPU环境的设置。 需要两步：
进程和线程
weixin_45590051的博客
05-08 1万+
一、进程和线程 进程是程序执行时的一个实例，即它是程序已经执行到何种程度的数据结构的汇集。从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。 线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。 一个进程由几个线程组成（拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构） 线程与同属一个进程的其他的线程共享进程所拥有的全部资源。 “进程——资源分配的最小单位，线程——程序执行的最小单位” 进程有独立的地址空间，一个进程崩溃
Python 文件处理注意事项总结
09-21
`logging` 是线程安全的，可以避免多线程或多进程同时写入同一日志文件时可能出现的问题。合理配置日志级别、格式和处理器，可以有效地跟踪和诊断程序运行状态。 6. 图像文件处理 对于基本的图像处理任务，如裁剪、...
UNIX自学总结上.zip
08-26
本篇将基于"UNIX自学总结上"的主题，结合《UNIX系统编程手册 下》这本书的内容，深入探讨UNIX系统的核心概念和技术。 一、UNIX系统基础 UNIX系统由Ken Thompson和Dennis Ritchie在20世纪60年代末创建，其设计理念是...
learningCoding：存储学习过程中写的代码
02-09
在编程学习的旅程中，...总结，"learningCoding：存储学习过程中写的代码"是一个涵盖Java基础到高级特性的实践宝库。通过研究这个压缩包，你可以深化对Java的理解，巩固编程技能，从而在软件开发的世界里游刃有余。
QT6.24 mingw_64编译QtXlsx
07-11
总结，本文详细介绍了如何在Qt 6.24 mingw_64环境下编译QtXlsx源代码，生成Qt 6.24的dll库，并在实际项目中测试其读写Excel文件的功能。通过这个过程，开发者可以轻松地在Qt应用中集成Excel文件支持，极大地扩展了Qt...
C语言关于使用waveout接口在Windows下的简易音乐播放界面
最新发布
03-02
不过不得不说，代码写的的确有点过于繁杂臃肿了，特别是线程和输入判断那块，本想将判断全部移入线程，但是线程本身必须要判断的就已经够多了，且还得用全局变量区传递信息，结果最后不知道该如何去修改很多可以精简...
Only老K说-爬取妹子图片（简单入门）
only老K的博客 qq:1025271924
06-27 5万+
安装第三方请求库 requests 被网站禁止了访问 原因是我们是Python过来的 重新给一段 可能还是存在用不了，使用网页的 编写代码 上面注意看匹配内容 User-Agent：请求对象 AppleWebKit：请求内核 Chrome浏览器 //请求网页 import requests import re //正则表达式 就是去不规则的网页里面提取有规律的信息 headers = { 'User-Agent':'存放浏览器里面的' } response = requests.get
Only老K说-为什么使用SSM框架
only老K的博客 qq:1025271924
03-14 3133
博客内容 为什么要使用SSM框架，就需要从什么是SSM框架开始说起… 那是一个非常悠久的传说… 回来回来，说哪里去了？先弄清楚什么是开发框架 开发框架是一套规则都写好的框架代码,塔帮助我们实现了很多基础性的功能,节省了程序员大量的编码工作，让程序员可以把更多精力放到系统业务逻辑处理上。例如Spring框架可以简化Java程序对数据库的访问，使用Spring框架访问数据既提高了数据库的访问效率和...
SpringCloud之jar包测试之If you want an embedded database please put a supported one on the classpath
only老K的博客 qq:1025271924
03-01 2272
报错问题 If you want an embedded database please put a supported one on the classpath 翻译如下：如果您想要嵌入式数据库，请在类路径中放置一个受支持的数据库 问题解析：这是因为spring boot默认会加载org.springframework.boot.autoconfigure.jdbc.DataSourceAut...
RabbitMQ启动报错：docker: Error response from daemon: driver failed programming external connectivity on
only老K的博客 qq:1025271924
03-02 1812
报错前提：运行如下代码： docker run -d -p 5672:5672 -p 15672:15672 --name rabbitmq rabbitmq:management 访问RabbitMQ进去失败。 全部报错信息： docker: Error response from daemon: driver failed programming external connectivity ...
Linux系统下的多线程编程入门
总结，Linux下的多线程编程能够帮助开发者编写出高效的并发程序，但也需要注意线程安全和资源管理，合理利用同步机制避免问题。通过学习和实践pthread库，可以熟练掌握在Linux环境中进行多线程编程，提升软件的并发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值