Java多线程

    xiaoxiao2021-03-25  7

    Runnable

    interface:它是一个接口run():它唯一的方法,一个run需要实现的方法,线程的逻辑写在这里 class RunnableDemo implements Runnable{ @override public void run(){ //do something... } } public static void main(String[] args){ Thread t = new Thread(new RunnableDemo()); t.start(); }

    Thread(单继承方式)

    class:首先它是一个类,它implements Runnable,getName()可以获取它的名字,setName()可以设置它的名字run():重写Runnable的方法,它也不实现,只是调用Runnable的run()start():the JVM calls the run method of thread.sleep():params is millis.yeild():the current thread is willing to yeild its current use of processor,the scheduler is free.join():wait for this thread to die.currentThread():return a reference to the currently executing thread object. class ThreadDemo extends Thread{ @override public void run(){ //do something } } public static void main(String[] args){ Thread t = new ThreadDemo(); t.start(); }

    Synchronized

    synchronized(object){}块实现线程互斥 运用Object的wait/notify/notifyAll方法实现线程同步

    synchronized(object){ object.wait(); object.notify(); obejct.notifyALl(); }

    wait():the current thread to wait until another thread invokes the notify() method or the notifyAll() for this object. synchronized也可用于修饰方式,一个被synchronized修饰的方法,保证了线程的安全性,这个方法没被执行完或者没有调用wait方法之前,其他线程都被阻塞,直到方法执行完或者调用wait方法。

    volatile

    保证了线程可以正确地读取其他线程写入的数据 原因:线程内存可见性,JMM,happens-before原则 注意:volatile只适用于更改数据不依赖于数据本身,比如boolean变量,温度变量等。

    Daemon

    守护线程

    thread.setDaemon(true) 在start()之前设置,否则会抛IllegalThreadStateException。在Daemon线程中产生的新线程也是Daemon的。不是所有的应用都可以分配给Daemon线程来进行服务,比如读写操作或者计算逻辑。因为如果没有线程让守护线程守护的话,Daemon Thread还没来的及进行操作时,Daemon Thread可能随着JVM退出了。

    Callable、Futrue、ExecutorService、CountDownLatch

    实现Callable接口类

    public class TestCallable implements Callable<Integer>{ private CountDownLatch countDownLatch; public TestCallable(CountDownLatch countDownLatch){ this.countDownLatch=countDownLatch; } @Override public Integer call() throws Exception { System.out.println(Thread.currentThread().getName()+"run..."); final long numSleep = 10000; int r = (int)(Math.random()*10); System.out.println("start sleep "+Math.floor(numSleep/1000)+" seconds..."); Thread.sleep(numSleep); System.out.println("wake up!"); countDownLatch.countDown(); System.out.println(Thread.currentThread().getName()+"end!"); return r; } }

    测试方法:

    public static void main(String[] args) throws InterruptedException, ExecutionException { final int numThread = 3; List<Future<Integer>> futureList = new ArrayList<>(); CountDownLatch countDownLatch = new CountDownLatch(numThread); // ExecutorService pool = Executors.newCachedThreadPool(); ExecutorService pool = Executors.newFixedThreadPool(numThread); for(int i=0;i<numThread;i++){ Callable<Integer> c1 = new TestCallable(countDownLatch); Thread.currentThread().setName("thread-"+i); futureList.add(pool.submit(c1)); } pool.shutdown(); countDownLatch.await(); for (Future<Integer> future : futureList) { if(future.isDone()){ System.out.println(future.get()); }else{ System.out.println("f is running..."); } } }

    单例模式的多线程问题: 用DCL(双重检测)解决单例模式中的懒汉模式的多线程问题中,为什么需要双层? volatile保证获取对象来判断对象是否为空的时候,获取的是公共栈中的对象(得到及时更新),asynchronized保证了创建对象的原子性。 为什么用内部类解决单例模式中的懒汉模式的多线程问题中,遇到序列化会创建多个对象?

    转载请注明原文地址: https://ju.6miu.com/read-200146.html

    最新回复(0)