JUC01

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量167 收藏
点赞数
文章标签： java 多线程 juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/evan_one/article/details/115208927
版权

1. JUC

java.util:工具包

2. 线程和进程

线程，进程，如果不能使用一句话说出来的技术，不扎实

进程：一个程序，QQ.exe Music.exe 程序的集合

一个进程往往可以包含多个线程，至少包含一个

Java默认有几个线程？2个 main线程和GC线程。

并发，并行

并发（多线程操作同一个资源）

  • CPU一核，模拟出多条线程，快速交替。

并行

  • CPU多核，多个线程可以同时执行；线程池。
// 获取cpu的核数
// CPU密集型，IO密集型
System.out.println(Runtime.getRuntime().availableProcessors());

wait不需要捕获异常？？？存疑

Lock锁（重点）

传统Synchronized

public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 并发：多个线程操作同一个资源类，把资源类丢入线程
        Ticket ticket = new Ticket();

        new Thread(() ->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() ->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() ->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "C").start();

    }
}

//资源类
class Ticket {
    private int number = 10;
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() +
                    "卖出了第" + (number--) + "票，剩余：" + number);
        }
    }
}

Lock接口

公平锁：十分公平：可以先来后到

非公平锁：十分不公平：可以插队（默认）

锁是什么，如何判断锁的是谁？

有序执行A->B->C

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                data.printA();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                data.printB();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                data.printC();
            }
        },"C").start();
    }
}

class Data2 {
    private int munber = 0;

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;

    public void printA() {
        lock.lock();
        try {
            while (number != 1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "-->AAAA");
            number = 2;
            //唤醒指定的人，B
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB() {
        lock.lock();
        try {
            while (number != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "-->BBBB");
            number = 3;
            //唤醒指定的人，B
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC() {
        lock.lock();
        try {
            //业务，判断-》执行-》通知
            while (number != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "-->CCCC");
            number = 1;
            //唤醒指定的人，B
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

5 八锁问题

synchronized:该关键字锁的对象是方法的调用者！

两个方法用的是同一把锁，谁先拿到谁先执行。

new this 具体的一个对象

static Class唯一的一个模板

两个普通同步方法

/**
 * 1.标准情况下，两个线程先打印发短信还是打电话 answer：发短信
 * 2.sendSms延迟4秒，两个线程先打印发短信还是打电话 answer：发短信
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        
        new Thread(() -> {
            phone.semdSms();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {phone.call();}, "B").start();
    }
}

class Phone {
    //  synchronized 锁的对象是方法的调用者
    //  两个方法用的是同一个锁，谁先拿到谁执行
    public synchronized void semdSms() {
        //情况2
//        try {
//            TimeUnit.SECONDS.sleep(4);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

非同步方法和同步方法

/**
 * 3.增加了一个普通方法后，先执行发短信还是hello？ answer： hello
 * 4.两个对象都执行同步方法 answer：打电话
 */
public class Test2 {
    public static void main(String[] args) {
        // 两个对象，两个调用者，两把锁
        Phone2 phone = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(() -> {
            phone.semdSms();
        }, "A").start();

        new Thread(() -> {
            phone2.call();
        }, "D").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {phone.call();}, "B").start();

        new Thread(() -> {
            phone.hello();
        }, "C").start();
    }
}

class Phone2 {
    //  synchronized 锁的对象是方法的调用者
    //  两个方法用的是同一个锁，谁先拿到谁执行
    public synchronized void semdSms() {
        //情况2
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }

    //hello 没有锁，不是同步锁，不受锁的影响
    public void hello() {
        System.out.println("hello");
    }
}

同步方法和静态同步方法

/**
 * 5.增加两个静态的同步方法，只有一个对象，先打电话还是发短信 answer 发短信
 * 6.两个对象，增加两个静态的同步方法。 answer 发短信
 */
public class Test3 {
    public static void main(String[] args) {
        // 两个对象，两个调用者，两把锁
        Phone3 phone = new Phone3();
        Phone3 phone3 = new Phone3();

        new Thread(() -> {
            phone.semdSms();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        问题5代码
//        new Thread(() -> {phone.call();}, "B").start();
        new Thread(() -> {phone3.call();}, "B").start();

    }
}
// Phone3 只有唯一的一个Class对象
class Phone3 {
    // synchronized 锁的对象是方法的调用者
    // static 静态方法，类一加载就有了！Class 是模板
    // 类一加载就有了！ 锁的是Class
    public static synchronized void semdSms() {
        //情况2
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call() {
        System.out.println("打电话");
    }
}

Class对象和类对象

/**
 * 7. 一个静态的同步方法，1个普通的同步方法，一个对象，先打印谁？ 打电话
 * 8. 一个静态的同步方法，一个普通的同步方法，两个对象，先打印谁？ 打电话
 * @author Evan
 * @date 2021/3/18 15:06
 */
public class Test4 {
    public static void main(String[] args) {
        // 两个对象，两个调用者，两把锁
        Phone4 phone = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(() -> {
            phone.semdSms();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
//        问题7的代码
//        new Thread(() -> {phone.call();}, "B").start();
        new Thread(() -> {phone2.call();}, "B").start();

    }
}

class Phone4 {
    // synchronized 锁的对象是方法的调用者
    // static 静态方法，类一加载就有了！Class 是模板
    // 类一加载就有了！ 锁的是Class
    public static synchronized void semdSms() {
        //情况2
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }

}

6、集合类不安全

List不安全

使用ArrayList

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() ->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

输出:出现ConcurrentModificationException

说明：测试中出现过不报错的情况，循环次数增加到20次仍会出现完全不报错的情况。

[null, 1770e, b15b8, 38f61, 804a5]
[null, 1770e, b15b8, 38f61, 804a5, 620f7, 71db8]
[null, 1770e, b15b8, 38f61, 804a5, 620f7, 71db8, a8acf]
[null, 1770e, b15b8, 38f61, 804a5, 620f7, 71db8]
[null, 1770e, b15b8, 38f61, 804a5, 620f7]
[null, 1770e, b15b8, 38f61, 804a5]
[null, 1770e, b15b8, 38f61, 804a5]
[null, 1770e, b15b8, 38f61, 804a5]
[null, 1770e, b15b8, 38f61, 804a5]
Exception in thread "0" java.util.ConcurrentModificationException

public class ListTest {
    public static void main(String[] args) {
        /**
         * ArrayList 并发下会出现ConcurrentModificationException
         * 解决方案
         * 1.List<String> list = new Vector<>();
         * 2.List<String> list = Collections.synchronizedList(new ArrayList<>());
         * 3.List<String> list = new CopyOnWriteArrayList<>();
         */

        /**
         * CopyOnWrite 写入时复制， 这是计算机程序设计领域的一种优化策略
         * 多个线程调用的时候，list，读取的时候，固定的，写入覆盖
         * 在写入的时候避免覆盖，造成数据问题
         * 读写分离
         */
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 200; i++) {
            new Thread(() ->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

set不安全

HashSet底层是什么

//hash底层就是hashmap，根据map的key不重复的特性建立集合
public HashSet() {
    map = new HashMap<>();
}
// add方法
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
	// Dummy value to associate with an Object in the backing Map
	// 与背景map中的对象关联的虚拟值
   	private static final Object PRESENT = new Object();

hash底层就是hashmap，key不重复

public class SetTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0,4));
                System.out.println(set);
            }, String.valueOf(i).toString()).start();
        }
    }
}

解决方案

public class SetTest {
    public static void main(String[] args) {
        /**
         * Set<String> set = new HashSet<>(); 出现ConcurrentModificationException
         * 解决方案
         * 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2.Set<String> set = new CopyOnWriteArraySet<>();
         */

        Set<String> set = new HashSet<>();

        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0,4));
                System.out.println(set);
            }, String.valueOf(i).toString()).start();
        }
    }
}

Map不安全

public class MapSet {
    public static void main(String[] args) {

        /**
         * map默认等价于什么？ new HashMap<>(16, 0.74) 和hashmap的原理有关
         * Map<String, String> map = new HashMap<>();
         * Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
         * Map<String, String> map = new ConcurrentHashMap<>();
         */
        Map<String, String> map = new HashMap<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            }).start();
        }
    }
}

7、Callable

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

        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);

        new Thread(futureTask, "A").start();
        new Thread(futureTask, "B").start(); //结果会被缓存，效率高
        // 此时，FutureTask的state已非new状态，则此时会直接结束对应的线程，就会导致任务也不执行
        // 只是在第一次调用时返回结果保存了。（网友弹幕）
        //这个get方法可能会产生阻塞！把他放在最后
        Integer o = (Integer) futureTask.get();
		// 主线程会在此处等待，futureTask.get()返回结果后继续执行
        System.out.println(o);
        System.out.println("快点快点");
    }
}

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("call()"); //会打印几个call,只打印了一个
        TimeUnit.SECONDS.sleep(3);
        // 耗时的操作
        return 1024;
    }
}

输出

call()
1024
快点快点

8、常用辅助类

CountDownLatch

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 总数是6， 必须要执行任务的时候，再使用
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "Go out");
                countDownLatch.countDown(); //数量-1
            }, String.valueOf(i)).start();
        }
        countDownLatch.await(); //等待计数器归零，然后再向下执行
        System.out.println("Close Door");
    }
}

输出

1Go out
5Go out
0Go out
4Go out
3Go out
2Go out
Close Door

每次有线程调用countDown()数量-1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行！

CyclicBarrier

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐7颗龙珠召唤神龙
         */
        // 召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙成功！");
        });

        for (int i = 0; i < 7; i++) {
            final int temp = i;
            //lambda表达式不能操作i，所以
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "收集" + temp + "个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

原理：

semaphore.acquire();获得，假设如果已经满了，等待，等待被释放为止！

semaphore.release();释放，会将当前的信号量释放+1，然后唤醒等待的线程！

作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！

9、读写锁

ReadWriteLock

读可以被多个线程同时读，写的时候只能有一个线程去写

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        //MyCache myCache = new MyCache();
        MyCacheLock myCache = new MyCacheLock();

        for (int i = 1; i <= 10; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }

        //读取
        for (int i = 1; i <= 10; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.get(temp + "");
            }, String.valueOf(i)).start();
        }

    }
}

//加读写锁
class MyCacheLock{
    private final Map<String, Object> map = new HashMap<>();
    // 读写锁：更加细粒度的控制
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final Lock lock = new ReentrantLock();
    // 存
    public void put(String key, Object value) {
        // 写锁
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入" + key);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入ok");
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }

    public void get(String key) {
        //实测读写10个线程不加锁，出现写入过程中读取，因此要加锁
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取" + key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取ok");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}
//不加锁
class MyCache{
    private volatile Map<String, Object> map = new HashMap<>();

    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "写入" + key);
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "写入ok");
    }

    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "读取" + key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取ok");
    }
}

10、阻塞队列

阻塞队列的使用场景：多线程并发处理，线程池！

四组API

.put 队列没有位置了，会一直阻塞

11、线程池

池化技术

线程池的好处

1、降低资源的消耗

2、提高响应的速度

3、方便管理

线程复用、

12、四大函数式接口

新时代的程序员：

lambda表达式

链式编程

函数式接口

Stream流计算

16、 JMM

请你谈谈Volatile的理解

Volatile是Java虚拟机提供轻量级的同步机制

  1. 保证可见性
  2. 不保证原子性
  3. 禁止指令重排

什么是JMM

Java内存模型，不存在的东西，是概念和约定

关于JMM的一些同步的约定

1、线程解锁前，必须把共享变量立刻刷回主存。

2、线程加锁前，必须读取主存中的最新值到工作内存中

3、加锁和解锁是同一把锁

线程 工作内存，主内存

public class JMMDemo {
    private static int num =0;

    public static void main(String[] args) {
        new Thread(() -> {
            while (num == 0) {

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }
}

设想的是num在主线程中赋值为1，new线程也因为num ！= 0而停止运行。实际运行时，new线程未停止。这是因为主内存中的num==1，而线程的工作内存未做相应的修改，因此不会停止运行。
解决办法见下一节。

17、Volatile

1、保证可见性

public class JMMDemo {
    private volatile static int num =0;
    // 不加 volatile 程序就会死循环
    // 加 volatile 可以保证可见性
    public static void main(String[] args) {
        new Thread(() -> { // 线程1对主内存的变化不知道
            while (num == 0) {

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }
}

2、不保证原子性

原子性：不可分割

线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败。

public class VDemo2 {
    private volatile static int num = 0;
    public static void add() {
        num++;
    }

    public static void main(String[] args) {
        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();

            while (Thread.activeCount() > 2) { // main gc 线程
                Thread.yield();
            }
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JdEcQga1-1616655476952)(…/image/image-20210322113602501.png)]

输出始终是20000，未出现视频中的小于20000的情况。但是idea会有警告。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LxYhg3wR-1616655476954)(…/image/image-20210322113722836.png)]

使用原子类解决原子性问题

public class VDemo3 {
    // 原子类的 Integer
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void add() {
        num.getAndIncrement(); // AtomicInteger + 1方法， CAS
    }

    public static void main(String[] args) {
        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();

            while (Thread.activeCount() > 2) { // main gc 线程
                Thread.yield();
            }
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }
}

这些类的底层都直接和操作系统挂钩！ 在内存中修改值！ Unsafe类是一个很特殊的存在。

Volatile是可以保持可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！

单例模式

搞懂单例模式和枚举

)]

输出始终是20000，未出现视频中的小于20000的情况。但是idea会有警告。

[外链图片转存中…(img-LxYhg3wR-1616655476954)]

使用原子类解决原子性问题

public class VDemo3 {
    // 原子类的 Integer
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void add() {
        num.getAndIncrement(); // AtomicInteger + 1方法， CAS
    }

    public static void main(String[] args) {
        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();

            while (Thread.activeCount() > 2) { // main gc 线程
                Thread.yield();
            }
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }
}

这些类的底层都直接和操作系统挂钩！ 在内存中修改值！ Unsafe类是一个很特殊的存在。

Volatile是可以保持可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！

单例模式

搞懂单例模式和枚举

构造器私有

搬砖中的Evan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java学习：01.JUC.md
01-22
Java是一种高级的面向对象的程序设计语言，它具有广泛的应用和强大的跨平台特性。Java语言于1995年由Sun公司推出，由Java之父詹姆斯高斯林设计。Java的设计目标是提供一种易学易用、功能强大的编程语言，使开发人员...
业级超高并发与高可用架构实现 JUC高并发编程 Java.Util.Concurrent源码+原理解析
06-16
课程从技术原理和细节上，进行非常详细的解读，是目前听过关于JUC企业级高并发最专业的课程，而高手往往在这些关键技术点上容易忽略，期待这个课程带给你更多技术的体验。 (1)\代码；目录中文件数:7个 ├─day01-...
JUC 01 补充 ThreadLocal
qq_38757863的博客
07-14 107
ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。01.ThreadLocal简介。
JUC01概述
Sky_小天
01-05 878
进程：程序是静止的，进程实体的运行过程就是进程，是系统进行资源分配的基本单位进程的特征：并发性、异步性、动态性、独立性、结构性线程：线程是属于进程的，是一个基本的 CPU 执行单元，是程序执行流的最小单元。线程是进程中的一个实体，是系统独立调度的基本单位，线程本身不拥有系统资源，只拥有一点在运行中必不可少的资源，与同属一个进程的其他线程共享进程所拥有的全部资源关系：一个进程可以包含多个线程，这就是多线程，比如看视频是进程，图画、声音、广告等就是多个线程。
【重难点】【JUC 01】线程安全都体现在哪些方面 、如何维护线程安全、多线程的同步方法、多线程通信方式、AQS
313YPHU3的博客
09-15 397
线程安全都体现在哪些方面 、如何维护线程安全、多线程的同步方法、多线程通信方式、AQS
JUC01——进程和线程
如不來的博客
10-12 6335
一、进程和线程  进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。  线程（thread） 是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际
01.juc
09-21 308
JUC1. 什么是JUC2. 进程和线程3. Lock锁4. 生产者和消费者4.1. 生产者和消费者问题Synchronized版4.2. JUC版本的生产者和消费者4.3. Condition实现精准通知唤醒5. 8锁的现象6. 集合类不安全6.1. List不安全6.2. Set不安全6.3. Map不安全6.4. HashMap数据结构及2的整数次幂探究6.5. HashMap加载因子及转红黑树探究6.6. ConcurrentHashMap的原理7. Callable8. 常用辅助类8.1.Cou
JUC01-synchronized及底层优化
qq_42861526的博客
10-31 192
大家对于synchronized应该不陌生，在我们实际业务中经常需要书写同步代码块来保证线程安全性，而synchronized便是我们常用的一个加锁方式。那么问题来了，在高并发的情况下，synchronized是如何保证线程安全的呢？
JUC——01
qq_36284689的博客
08-20 80
目录1.1 JUC是什么？1.1.1 进程与线程1.1.2 wait/sleep的区别1.1.3 并发与并行2.1 创建线程方式2.1.1 代码实现2.2.2 关于同步1.1 JUC是什么？ JUC 全称叫做：java.util.concurrent。是在并发编程中使用的工具类。 1.1.1 进程与线程 进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的...
JUC-01概述
Logan的博客
08-20 185
1 什么是 JUC 1.1 JUC 简介 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 进程与线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算
【JUC —— 01 JUC介绍】
m0_72328778的博客
07-09 358
Java JUC（Java Util Concurrent）是Java提供的一套用于并发编程的工具包，它提供了许多类和接口来简化和优化多线程编程。JUC主要包括并发集合、同步工具、执行器框架、锁机制等。
2021-06-10 JUC01DAY
pangiggs的博客
06-10 50
public class TEst1 { public static void main(String[] args) throws InterruptedException { Tciket01 tciket01 = new Tciket01(); //获取CPU线程 //CPU密集型 IO密集型 System.out.println(Runtime.getRuntime().availableProcessors());
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
java高级技术JUC高并发编程教程2021(1.5G)
04-11
01-JUC高并发编程-课程介绍.mp4 02-JUC高并发编程-JUC概述和进程线程概念（1）.mp4 03-JUC高并发编程-JUC概述和进程线程概念（2）.mp4$ T/ H9 R! n2 l9 a b 04-JUC高并发编程-JUC概述和进程线程概念（3）.mp4 05-...
长虹iTV32750X液晶电视刷机数据v1.07，主板JUC7.820.00041505屏T315XF01，支持工厂强制升级
01-08
1、压缩包解压，images_t3文件夹复制放优盘根目录 2、按电源键进入待机，优盘插上电视USB接口； 3、找到电视机的音量加/减键，或者菜单键，按住不放； 4、将遥控器对准电视机左下角的遥控接收孔，按一下数字键“3”...
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
weixin_70987470的博客
07-20 345
从本地导入Junit
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 953
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 712
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 739
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值