17_juc

最新推荐文章于 2022-07-25 19:54:27 发布
最新推荐文章于 2022-07-25 19:54:27 发布
阅读量450 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsswshxcg/article/details/108580663
版权

Java JUC简介

在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。

volatile关键字-内存可见性

概述

  • 内存可见性（Memory Visibility）是指当某个线程正在使用对象状态 而另一个线程在同时修改该状态，需要确保当一个线程修改了对象 状态后，其他线程能够看到发生的状态变化。

  • 可见性错误是指当读操作与写操作在不同的线程中执行时，我们无 法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚 至是根本不可能的事情。

  • 我们可以通过同步来保证对象被安全地发布。除此之外我们也可以 使用一种更加轻量级的 volatile 变量。

volatile关键字

  • volatile关键字：调用计算机底层代码，将线程修改过后的数据（堆之类的）实时刷新。其实是volatile关键字修饰的变量不会再被线程缓存，线程向操作就只能去主存中读取，保证每个线程拿到的数据都是最新的。

  • Java 提供了一种稍弱的同步机制，即 volatile 变 量，用来确保将变量的更新操作通知到其他线程。 可以将 volatile 看做一个轻量级的锁，但是又与 锁有些不同：

    • 对于多线程，不是一种互斥关系
    • 不能保证变量状态的“原子性操作”

  • volatile 关键字：但多个线程操作共享数据时，可以保证内存中的数据可见。相较于synchronized是一种较为轻量级的同步策略。

// 这个变量在内存中可见。因为每个线程都有自己的缓冲区，导致线程之间内存不可见。
// 如果线程需要操作主存中的数据（deap，method area），为了提交效率线程会将要操作的主存数据copy到当前线程的缓存中
// 加了volatile 之后，线程操作使用volatile修饰的数据时，能够实时的读取到主存的数据（底层是有一个内存栅栏调用底层代码保证数据的实时性）
private volatile boolean flag = false;

死循环问题

jvm为了提高效率，会给每个线程分配缓冲空间（虚拟机栈），如果线程有使用到堆里面的东西，会先把这个东西copy到当前线程的缓冲中，如果该线程对这个数据进行的修改操作，会在缓存中修改，然后copy到主线程，实现数据的操作（一个进程有多个线程，进程有自己的堆和方法区，线程有自己的虚拟机栈和程序计数器，进程里面的线程可以操作进程里面的数据，实现线程间数据共享。）

然后where(true) 是很底层的代码，执行效率很快，没有时间读取主存中刚修改过的数据，导致死循环。

image-20200914085810672

class Test {
    public static void main(String[] args) {
        Runnable1 rb = new Runnable1();
        new Thread(rb).start();
				
       // 由于线程的之间的内存不可见性，会导致死锁
        while (true) {
            // 解决办法一：休眠一段时间，让子线程先执行完
           /*try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            */
          
          // 解决办法二，加锁
          // synchronized (rb) {
                if (rb.isFlag()) {
                    System.out.println("-----------------");
                    break;
                }
           // }
        }
    }
}

class Runnable1 implements Runnable {

    private boolean flag = false;

    public boolean isFlag() {
        return flag;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (Exception e) {
            e.printStackTrace();
        }
        flag = true;
        if (flag) {
            System.out.println("flag=" + flag);
        }
    }
}

使用volatile关键字

==使用volatile关键字之后，就会有一个内存栅栏调用底层代码实时刷新线程里面的共享数据到主存中。我们可以理解成我们读写都是直接操作主存的数据。==因为实时读取刷新主存的数据所以效率相对低一点，但是比使用synchronized快。

class Test {
    public static void main(String[] args) {
        Runnable1 rb = new Runnable1();
        new Thread(rb).start();

        while (true) {

            if (rb.isFlag()) {
                System.out.println("-----------------");
                break;
            }
        }
    }
}

class Runnable1 implements Runnable {

    private volatile boolean flag = false;

    public boolean isFlag() {
        return flag;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (Exception e) {
            e.printStackTrace();
        }
        flag = true;
        if (flag) {
            System.out.println("flag=" + flag);
        }
    }
}

原子变量-CAS算法

CAS算法概述

  • CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器 操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并 发访问。

  • CAS 是一种无锁的非阻塞算法的实现。

  • CAS 包含了 3 个操作数：

    • 需要读写的内存值 V
    • 进行比较的值 A
    • 拟写入的新值 B

  • 当且仅当 V 的值等于 A 时，CAS 通过原子方式用新值 B 来更新 V 的 值，否则不会执行任何操作。

原子变量

  • 类的小工具包，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可 将 volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。

  • 类 AtomicBoolean、AtomicInteger、AtomicLong 和 AtomicReference 的实例各自提供对 相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。

  • AtomicIntegerArray、AtomicLongArray 和 AtomicReferenceArray 类进一步扩展了原子操 作，对这些类型的数组提供了支持。这些类在为其数组元素提供 volatile 访问语义方 面也引人注目，这对于普通数组来说是不受支持的。

  • 核心方法：boolean compareAndSet(expectedValue, updateValue)

  • java.util.concurrent.atomic 包下提供了一些原子操作的常用类:

    AtomicBoolean 、AtomicInteger 、AtomicLong 、 AtomicReference AtomicIntegerArray 、AtomicLongArray

    AtomicMarkableReference

    AtomicReferenceArray

image-20200914094727007

image-20200914101256005

/*
 * 一、i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”
 * 		  int i = 10;
 * 		  i = i++; //10
 *
 * 		  int temp = i;
 * 		  i = i + 1;
 * 		  i = temp;
 *
 * 二、原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
 * 		1. volatile 保证内存可见性(可以看成实时想主存中读取数据)
 * 		2. CAS（Compare-And-Swap） 算法保证数据变量的原子性
 * 			CAS 算法是硬件对于并发操作的支持（计算机底层的支持 ）
 * 			CAS 包含了三个操作数：计算机底层保证了 比较和替换的原子性
 * 			①内存值  V （先读取内存值）
 * 			②预估值  A （再次获取内存值）
 * 			③更新值  B
 * 			当且仅当 V == A 时， V = B; 否则，不会执行任何操作,此时不会失去cpu的执行权，所以我们可以写代码判断一下，不要浪费这一次拿到cpu执行权的机会（所以效率比synchronized高）
 */
public class TestAtomicDemo {

    public static void main(String[] args) {
        AtomicDemo ad = new AtomicDemo();

        for (int i = 0; i < 10; i++) {
            new Thread(ad).start();
        }
    }

}

class AtomicDemo implements Runnable {

//    private int serialNumber = 0;
//	private volatile int serialNumber = 0;

    private AtomicInteger serialNumber = new AtomicInteger(0);

    @Override
    public void run() {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }

        System.out.println(getSerialNumber());
    }

    public int getSerialNumber() {
//        return serialNumber++;
        return serialNumber.getAndIncrement();
    }


}

模拟CAS算法

/*
 * 模拟 CAS 算法
 */
public class TestCompareAndSwap {

	public static void main(String[] args) {
		final CompareAndSwap cas = new CompareAndSwap();
		
		for (int i = 0; i < 10; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					int expectedValue = cas.get();
					boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
					System.out.println(b);
				}
			}).start();
		}
		
	}
	
}

class CompareAndSwap{
	private int value;
	
	//获取内存值
	public synchronized int get(){
		return value;
	}
	
	//比较
	public synchronized int compareAndSwap(int expectedValue, int newValue){
		int oldValue = value;
		
		if(oldValue == expectedValue){
			this.value = newValue;
		}
		
		return oldValue;
	}
	
	//设置
	public synchronized boolean compareAndSet(int expectedValue, int newValue){
		return expectedValue == compareAndSwap(expectedValue, newValue);
	}
}

ConcurrentHashMap 锁分段机制

概述

  • Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器 的性能。
  • ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对 与多线程的操作，介于 HashMap 与 Hashtable 之间。内部采用“锁分段” 机制替代 Hashtable 的独占锁。进而提高性能。
  • 此包还提供了设计用于多线程上下文中的 Collection 实现： ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、 CopyOnWriteArrayList 和 CopyOnWriteArraySet。当期望许多线程访问一个给 定 collection 时，ConcurrentHashMap 通常优于同步的 HashMap， ConcurrentSkipListMap 通常优于同步的 TreeMap。当期望的读数和遍历远远 大于列表的更新数时，CopyOnWriteArrayList 优于同步的 ArrayList。

image-20200914102910437

/*
 * CopyOnWriteArrayList/CopyOnWriteArraySet : “写入并复制”
 * 注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。
 */
public class TestCopyOnWriteArrayList {

	public static void main(String[] args) {
		HelloThread ht = new HelloThread();
		
		for (int i = 0; i < 10; i++) {
			new Thread(ht).start();
		}
	}
	
}

class HelloThread implements Runnable{
	
//	private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
	
	private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
	
	static{
		list.add("AA");
		list.add("BB");
		list.add("CC");
	}

	@Override
	public void run() {
		
		Iterator<String> it = list.iterator();
		
		while(it.hasNext()){
			System.out.println(it.next());
			
			list.add("AA");
		}
		
	}
	
}

CountDownLatch 闭锁

  • Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器 的性能。
  • CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作 之前，它允许一个或多个线程一直等待。
  • 闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活 动直到其他活动都完成才继续执行：
    • 确保某个计算在其需要的所有资源都被初始化之后才继续执行;
    • 确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
    • 等待直到某个操作所有参与者都准备就绪再继续执行。
/*
 * CountDownLatch ：闭锁，在完成某些运算是，只有其他所有线程的运算全部完成，当前运算才继续执行
 */
public class TestCountDownLatch {

	public static void main(String[] args) {
		final CountDownLatch latch = new CountDownLatch(50);
		LatchDemo ld = new LatchDemo(latch);

		long start = System.currentTimeMillis();

		for (int i = 0; i < 50; i++) {
			new Thread(ld).start();
		}

		try {
			latch.await();
		} catch (InterruptedException e) {
		}

		long end = System.currentTimeMillis();

		System.out.println("耗费时间为：" + (end - start));
	}

}

class LatchDemo implements Runnable {

	private CountDownLatch latch;

	public LatchDemo(CountDownLatch latch) {
		this.latch = latch;
	}

	@Override
	public void run() {

		try {
			for (int i = 0; i < 50000; i++) {
				if (i % 2 == 0) {
					System.out.println(i);
				}
			}
		} finally {
			latch.countDown();
		}

	}

}

实现Callable接口

  • Java 5.0 在 java.util.concurrent 提供了一个新的创建执行线程的方式：Callable 接口
  • Callable 接口类似于 Runnable，两者都是为那些其实例可 能被另一个线程执行的类设计的。但是 Runnable 不会返 回结果，并且无法抛出经过检查的异常。
  • Callable 需要依赖FutureTask ，FutureTask 也可以用作闭锁。
/*
 * 一、创建执行线程的方式三：实现 Callable 接口。 相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常。
 * 
 * 二、执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。  FutureTask 是  Future 接口的实现类
 */
public class TestCallable {
	
	public static void main(String[] args) {
		ThreadDemo td = new ThreadDemo();
		
		//1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
		FutureTask<Integer> result = new FutureTask<>(td);
		
		new Thread(result).start();
		
		//2.接收线程运算后的结果
		try {
			Integer sum = result.get();  //FutureTask 可用于 闭锁,因为调用get()方法，只有线程执行完才能解锁使程序向下执行
			System.out.println(sum);
			System.out.println("------------------------------------");
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}

}

class ThreadDemo implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		
		for (int i = 0; i <= 100000; i++) {
			sum += i;
		}
		
		return sum;
	}
	
}

Lock （同步锁）

  • 在 Java 5.0 之前，协调共享对象的访问时可以使用的机 制只有 synchronized 和 volatile 。Java 5.0 后增加了一些 新的机制，但并不是一种替代内置锁的方法，而是当内 置锁不适用时，作为一种可选择的高级功能。
  • ReentrantLock 实现了 Lock 接口，并提供了与 synchronized 相同的互斥性和内存可见性。但相较于 synchronized 提供了更高的处理锁的灵活性。

Condition控制线程通信

  • Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用 法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的 功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关 联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版 本中的不同。

  • 在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是 await、signal 和 signalAll。

  • Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，请使用其 newCondition() 方法。

线程按序交替

想要实现按序交替就肯定涉及到线程的通信

class testOrderDemo {
    public static void main(String[] args) {
        OrderDemo od = new OrderDemo();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    od.loopA(i);
                }
            }

        }, "A").start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    od.loopB(i);
                }
            }

        }, "B").start();


        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    od.loopC(i);
                }
            }

        }, "C").start();
    }
}

class OrderDemo {
    private int num = 1;
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void loopA(int totalNum) { // 第几次循环
        lock.lock();

        try {
            if (num != 1) {
                // 等待，
                try {
                    condition1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "第几轮：" + totalNum);
            }

            // 打印完成唤醒别的线程
            num = 2;
            condition2.signal();
        } finally {
            lock.unlock();
        }

    }

    public void loopB(int totalNum) { // 第几次循环
        lock.lock();

        try {
            if (num != 2) {
                // 等待，
                try {
                    condition2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "第几轮" + totalNum);
            }

            // 打印完成唤醒别的线程
            num = 3;
            condition3.signal();
        } finally {
            lock.unlock();
        }

    }


    public void loopC(int totalNum) { // 第几次循环
        lock.lock();

        try {
            if (num != 3) {
                // 等待，
                try {
                    condition3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "第几轮" + totalNum);
            }
            System.out.println("-------------");
            // 打印完成唤醒别的线程
            num = 1;
            condition1.signal();
        } finally {
            lock.unlock();
        }

    }
}

ReadWriteLock读写锁

  • ReadWriteLock 维护了一对相关的锁，一个用于只读操作， 另一个用于写入操作。只要没有 writer，读取锁可以由 多个 reader 线程同时保持。写入锁是独占的。。
  • ReadWriteLock 读取操作通常不会改变共享资源，但执行 写入操作时，必须独占方式来获取锁。对于读取操作占 多数的数据结构。 ReadWriteLock 能提供比独占锁更高 的并发性。而对于只读的数据结构，其中包含的不变性 可以完全不需要考虑加锁操作。
ReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLoack().lock();
lock.readLoack().unlock();

lock().writeLock().lock();
lock().writeLock().unlock();

/*
 * 1. ReadWriteLock : 读写锁
 * 
 * 写写/读写 需要“互斥”
 * 读读 不需要互斥
 * 
 */
public class TestReadWriteLock {

	public static void main(String[] args) {
		ReadWriteLockDemo rw = new ReadWriteLockDemo();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				rw.set((int)(Math.random() * 101));
			}
		}, "Write:").start();
		
		
		for (int i = 0; i < 100; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					rw.get();
				}
			}).start();
		}
	}
	
}

class ReadWriteLockDemo{
	
	private int number = 0;
	
	private ReadWriteLock lock = new ReentrantReadWriteLock();
	
	//读
	public void get(){
		lock.readLock().lock(); //上锁
		
		try{
			System.out.println(Thread.currentThread().getName() + " : " + number);
		}finally{
			lock.readLock().unlock(); //释放锁
		}
	}
	
	//写
	public void set(int number){
		lock.writeLock().lock();
		
		try{
			System.out.println(Thread.currentThread().getName());
			this.number = number;
		}finally{
			lock.writeLock().unlock();
		}
	}
}

线程八锁

弄懂同步监视器是谁，就能搞定这些问题

/*
 * 题目：判断打印的 "one" or "two" ？
 * 
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one  two
 * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one  two
 * 3. 新增普通方法 getThree() , 打印? //three  one   two
 * 4. 两个普通同步方法，两个 Number 对象，打印?  //two  one
 * 5. 修改 getOne() 为静态同步方法，打印?  //two   one
 * 6. 修改两个方法均为静态同步方法，一个 Number 对象?  //one   two
 * 7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象?  //two  one
 * 8. 两个静态同步方法，两个 Number 对象?   //one  two
 * 
 * 线程八锁的关键：
 * ①非静态方法的锁默认为  this,  静态方法的锁为 对应的 Class 实例
 * ②某一个时刻内，只能有一个线程持有锁，无论几个方法。
 */
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number = new Number();
		Number number2 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			} 
		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
//				number.getTwo();
				number2.getTwo();
			}
		}).start();
		
		/*new Thread(new Runnable() {
			@Override
			public void run() {
				number.getThree();
			}
		}).start();*/
		
	}

}

class Number{
	
	public static synchronized void getOne(){//Number.class
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
		}
		
		System.out.println("one");
	}
	
	public synchronized void getTwo(){//this
		System.out.println("two");
	}
	
	public void getThree(){
		System.out.println("three");
	}
	
}

线程池

  • 第四种获取线程的方法：线程池，一个 ExecutorService，它使用可能的几个池线程之 一执行每个提交的任务，通常使用 Executors 工厂方法配置。
  • 线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在 执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行 任务集时使用的线程）的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数 据，如完成的任务数。
  • 为了便于跨大量上下文使用，此类提供了很多可调整的参数和扩展钩子 (hook)。但 是，强烈建议程序员使用较为方便的 Executors 工厂方法 ：
Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收） Executors.newFixedThreadPool(int)（固定大小线程池） Executors.newSingleThreadExecutor()（单个后台线程） 

它们均为大多数使用场景预定义了设置。

/*
 * 一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。
 * 
 * 二、线程池的体系结构：
 * 	java.util.concurrent.Executor : 负责线程的使用与调度的根接口
 * 		|--**ExecutorService 子接口: 线程池的主要接口
 * 			|--ThreadPoolExecutor 线程池的实现类
 * 			|--ScheduledExecutorService 子接口：负责线程的调度
 * 				|--ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor， 实现 ScheduledExecutorService
 * 
 * 三、工具类 : Executors 
 * ExecutorService newFixedThreadPool() : 创建固定大小的线程池
 * ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
 * ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程
 * 
 * ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。
 */
public class TestThreadPool {
	
	public static void main(String[] args) throws Exception {
		//1. 创建线程池
		ExecutorService pool = Executors.newFixedThreadPool(5);
		
		List<Future<Integer>> list = new ArrayList<>();
		
		for (int i = 0; i < 10; i++) {
			Future<Integer> future = pool.submit(new Callable<Integer>(){

				@Override
				public Integer call() throws Exception {
					int sum = 0;
					
					for (int i = 0; i <= 100; i++) {
						sum += i;
					}
					
					return sum;
				}
				
			});

			list.add(future);
		}
		
		pool.shutdown();
		
		for (Future<Integer> future : list) {
			System.out.println(future.get());
		}
		
		
		
		/*ThreadPoolDemo tpd = new ThreadPoolDemo();
		
		//2. 为线程池中的线程分配任务
		for (int i = 0; i < 10; i++) {
			pool.submit(tpd);
		}
		
		//3. 关闭线程池
		pool.shutdown();*/
	}
	
//	new Thread(tpd).start();
//	new Thread(tpd).start();

}

class ThreadPoolDemo implements Runnable{

	private int i = 0;
	
	@Override
	public void run() {
		while(i <= 100){
			System.out.println(Thread.currentThread().getName() + " : " + i++);
		}
	}
	
}

线程调度

就是可以设置线程的延时启动

一个 ExecutorService，可安排在给定的延迟后运行或定 期执行的命令。

/* 
* ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。
 */
public class TestScheduledThreadPool {

	public static void main(String[] args) throws Exception {
		ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
		
		for (int i = 0; i < 5; i++) {
			Future<Integer> result = pool.schedule(new Callable<Integer>(){

				@Override
				public Integer call() throws Exception {
					int num = new Random().nextInt(100);//生成随机数
					System.out.println(Thread.currentThread().getName() + " : " + num);
					return num;
				}
				
			}, 1, TimeUnit.SECONDS);
			
			System.out.println(result.get());
		}
		
		pool.shutdown();
	}
	
}

ForkJoinPool 分支/合并框架 工作窃取

image-20200914153431418

  • 采用 “工作窃取”模式（work-stealing）： 当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加

  • 到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队 列中。  相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务 的处理方式上.在一般的线程池中，如果一个线程正在执行的任务由于某些 原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架实现中， 如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理 该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了 线程的等待时间，提高了性能。

public class TestForkJoinPool {
	
	public static void main(String[] args) {
		Instant start = Instant.now();
		
		ForkJoinPool pool = new ForkJoinPool();
		
		ForkJoinTask<Long> task = new ForkJoinSumCalculate(0L, 50000000000L);
		
		Long sum = pool.invoke(task);
		
		System.out.println(sum);
		
		Instant end = Instant.now();
		
		System.out.println("耗费时间为：" + Duration.between(start, end).toMillis());//166-1996-10590
	}
	
	@Test
	public void test1(){
		Instant start = Instant.now();
		
		long sum = 0L;
		
		for (long i = 0L; i <= 50000000000L; i++) {
			sum += i;
		}
		
		System.out.println(sum);
		
		Instant end = Instant.now();
		
		System.out.println("耗费时间为：" + Duration.between(start, end).toMillis());//35-3142-15704
	}
	
	//java8 新特性
	@Test
	public void test2(){
		Instant start = Instant.now();
		
		Long sum = LongStream.rangeClosed(0L, 50000000000L)
							 .parallel()
							 .reduce(0L, Long::sum);
		
		System.out.println(sum);
		
		Instant end = Instant.now();
		
		System.out.println("耗费时间为：" + Duration.between(start, end).toMillis());//1536-8118
	}

}

class ForkJoinSumCalculate extends RecursiveTask<Long>{

	/**
	 * 
	 */
	private static final long serialVersionUID = -259195479995561737L;
	
	private long start;
	private long end;
	
	private static final long THURSHOLD = 10000L;  //临界值
	
	public ForkJoinSumCalculate(long start, long end) {
		this.start = start;
		this.end = end;
	}

	@Override
	protected Long compute() {
		long length = end - start;
		
		if(length <= THURSHOLD){
			long sum = 0L;
			
			for (long i = start; i <= end; i++) {
				sum += i;
			}
			
			return sum;
		}else{
			long middle = (start + end) / 2;
			
			ForkJoinSumCalculate left = new ForkJoinSumCalculate(start, middle); 
			left.fork(); //进行拆分，同时压入线程队列
			
			ForkJoinSumCalculate right = new ForkJoinSumCalculate(middle+1, end);
			right.fork(); //
			
			return left.join() + right.join();
		}
	}
	
}
haitaoss
关注
专栏目录
c++ linux 线程等待与唤醒_C++ 线程的创建、挂起、唤醒和结束 &&&& 利用waitForSingleObject 函数陷入死锁的问题解决...
weixin_42350755的博客
12-23 504
最近在写一个CAN总线的上位机软件，利用CAN转USB的设备连到电脑上，进行数据的传输。在接收下位机发送的数据的时候采用的在线程中持续接收数据。1、在连接设备的函数中，开启线程。//在创建线程的时候，将线程挂起，挂起的线程可设置下面的m_bAutoDelete 等属性，再进行线程的唤醒m_pThread = AfxBeginThread(ReceiveThread,this,0,CREATE_SU...
C++大量线程等待与唤醒
kpengk的博客
06-20 1万+
一、线程唤醒方法 C++11之后提供了thread线程类，可以很方便的编写多线程程序。线程的等待和唤醒使用条件变量condition_variable和锁mutex结合实现，其中条件变量提供了wait(), notify(), notifyAll()等方法。 wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用，则是唤醒当前条件变量上的等待线程；notify()是随机唤醒单个等待的线程，而notifyAll()是唤醒
Java 之 JUC
weixin_34160277的博客
11-11 308
1. JUC 简介 在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中 的 Collection 实现等; 2. volatile 关键字 volatile 关键字: 当多个线程进行操作共享数据时,可以保证...
c++ linux 线程等待与唤醒_C++并发编程 等待与唤醒
weixin_39915210的博客
12-23 414
C++并发编程 等待与唤醒条件变量条件变量, 包括(std::condition_variable 和 std::condition_variable_any)定义在 condition_variable 头文件中, 它们都需要与互斥量(作为同步工具)一起才能工作.std::condition_variable 允许阻塞一个线程, 直到条件达成.成员函数void wait(std::unique_...
JAVA------多线程之探究同步
山海可平的博客
09-24 231
问题提出 今假设今天晚上北京到上海的高铁只剩下1张二等座，购票流程为查询余票，付钱，出票三个步骤。此时张三和李四分别在不同的窗口购票，若此时没有同步机制，则可能出现张三在出票前，李四查询任然有一张余票，可付款，出票，则此时会出现一张票同时卖给两个人。这种情况当然是不允许的，不然春运回家时会发现你的座位上坐着一个抠脚大汉。。。。 解决方法 解决方法很简单，只要保证张三访问火车票在退出（出票）前，其他人（李四）不能够访问操作这张票就可以。 线程同步 由上述例子...
java juc 集合_Java多线程系列--“JUC集合”02之 CopyOnWriteArrayList
热门推荐
weixin_29698641的博客
02-27 2万+
1 /*2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.3 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.4 *5 *6 *7 *8 *9 *10 *11 *12 *13 *14 *15 *16 *1...
java juc 集合_Java多线程系列--“JUC集合”03之 CopyOnWriteArraySet
weixin_29634081的博客
02-27 2545
1 /*2 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.3 *4 *5 *6 *7 *8 *9 *10 *11 *12 *13 *14 *15 *16 *17 *18 *19 *20 *21 *22 *23 */2425 /*26 *27 *28 *29 *30 *31 * Written by Doug ...
JUC笔记
qq_44789658的博客
07-25 907
JUC 基础知识
Java 多线程与并发(17-26)-JUC线程池- FutureTask详解.pdf
最新发布
07-28
### Java多线程与并发(17-26)-JUC线程池-FutureTask详解 #### 一、概述 本文将围绕Java多线程与并发中的重要概念——`FutureTask`进行深入探讨。`FutureTask`是Java并发库中的一个关键组件，它实现了`...
最全的并发编程JUC 笔记 Typora 版
10-03
JUC 笔记 基于JDK 17
c++调用栈库函数_c/c++ linux：线程的创建、线程等待、线程终止、线程分离
weixin_39700215的博客
11-12 290
1. 什么是线程线程是进程执行内部的一个执行分支，在一个进程内部运行的多种执行流；内部本质上是多个线程在同一个地址空间运行；第一个pcb称之为主线程；有多个线程就有多个执行流；一个进程至少有一个线程2. 图解线程PCB2所代表的进程通过vfork创建一个子进程，子进程再vfork一个新的子进程，以此类推产生两个新的子进程；此时PCB1、PCB2、PCB3都指向同一块虚拟地址空间，通过操作把PCB1...
Pthread多线程编程之查看Pthread版本的方法
ctrigger的专栏
11-27 868
Pthread多线程编程之查看Pthread版本的方法： getconf GNU_LIBPTHREAD_VERSION [root@localhost Workspace]# getconf GNU_LIBPTHREAD_VERSION NPTL 2.32
juc java_详解JUC 常用4大并发工具类
weixin_26831583的博客
02-17 427
什么是JUC?JUC就是java.util.concurrent包,这个包俗称JUC,里面都是解决并发问题的一些东西该包的位置位于java下面的rt.jar包下面4大常用并发工具类:CountDownLatchCyclicBarrierSemaphoreExChangerCountDownLatch:CountDownLatch,俗称闭锁,作用是类似加强版的Join,是让一组线程等待其他的线程完成...
Java JUC
qq_42076531的博客
10-02 172
Java JUC 1 Java JUC简介 在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。 2 volatile 关键字-内存可见性 2.1 内存可见性 Java 内存模型规定，对于多个线程共享的变量，存储在主内存当中，每个线程都有自己独立的工
java之juc详解
weixin_44295960的博客
02-17 743
实现线程的几种方式 继承Thread类 实现Runnable接口 实现Callable接口 从线程池中获取 Runnable接口和Callable接口的主要区别在于：Runnable接口没有返回值，而Callable接口call方法有返回值。 线程的状态主要分为6种：初始、运行、阻塞、等待、超时等待、终止 start()方法和run()方法的主要区别在于start是启动一个线程，而run方法是开始执行线程里的方法。 死锁 什么是线程死锁？ 死锁是指两个或者两个以上的线程在执行的过程中，由于相互竞争资源而
进程通讯-Condition
oneSeekers的博客
10-20 193
进程之间通讯-Condition await/signal/signalAll await(): 调用await方法的线程释放当前的lock，当前线程处于等待状态。类似于synchronized的wait()方法。 signal(): 调用signal方法使得当前condition的wait线程处于唤醒状态。 类似于synchronized的notify()方法，如果存在多个wait线程，signal()方法可以指定唤醒某个线程，notify()只能随机唤醒一个。 signalAll(): 调用sig
Java - JUC详解
S mile0804的博客
04-02 5768
一、概述 1.1 什么是JUC？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！ 1.2 什么是进程？ 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至CPU，数据加载至内存。在指令运行过程中还要用到磁盘、网络等设备。进程就是用来加载指令，管理内存管理IO的。 当一个进程被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为一个实例。
C++多线程编程——线程的挂起、唤醒与终止
张人杰的博客
02-05 1万+
C++多线程编程——线程的挂起、唤醒与终止 (2010-10-11 10:09:04) 转载▼ 标签： 杂谈 分类：Win32 在线程创建并运行后,用户可以对线程执行挂起和终止操作.所谓挂起,是指暂停线程的执行,用户可以通过气候的唤醒操作来恢复线程的执行.线程终止是指结束线程的运行.系统提供了SuspendThread,ResumeThrea
wait放弃对象锁_Java线程中wait、await、sleep、yield、join用法总结
weixin_34966468的博客
01-07 302
一、wait()、notify()、notifyAll()用法obj.wait()/obj.wait(long timeout)是Object中的方法，当线程调用wait()方法，当前线程释放对象锁，进入等待队列。obj.notify()/obj.nogifyAll()是Object中的方法，唤醒在此对象上wait()的单个或者所有线程。测试代码：public class ThreadWaitNo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值