Java多线程详解4【面试+工作】​

Java多线程详解【面试+工作】

Java线程:并发协作-死锁

线程发生死锁可能性很小,即使看似可能发生死锁的代码,在运行时发生死锁的可能性也是小之又小。

发生死锁的原因一般是两个对象的锁相互等待造成的。

在《Java线程:线程的同步与锁》一文中,简述死锁的概念与简单例子,但是所给的例子是不完整的,这里给出一个完整的例子。

/** 
* Java线程:并发协作-死锁
* 
* @author Administrator 2009-11-4 22:06:13 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
                DeadlockRisk dead = new DeadlockRisk();
                MyThread t1 = new MyThread(dead, 1, 2);
                MyThread t2 = new MyThread(dead, 3, 4);
                MyThread t3 = new MyThread(dead, 5, 6);
                MyThread t4 = new MyThread(dead, 7, 8);

                t1.start(); 
                t2.start(); 
                t3.start(); 
                t4.start(); 
        } 

} 

class MyThread extends Thread { 
 private DeadlockRisk dead;
 privateint a, b;


        MyThread(DeadlockRisk dead, int a,int b) { 
 this.dead = dead;
 this.a = a;
 this.b = b;
        } 

        @Override 
 publicvoid run() {
                dead.read(); 
                dead.write(a, b); 
        } 
} 

class DeadlockRisk {
 privatestaticclass Resource {
 publicint value;
        } 

 private Resource resourceA =new Resource(); 
 private Resource resourceB =new Resource(); 

 publicint read() {
 synchronized (resourceA) {
                        System.out.println("read():" + Thread.currentThread().getName() +"获取了resourceA的锁!");
 synchronized (resourceB) {
                                System.out.println("read():" + Thread.currentThread().getName() +"获取了resourceB的锁!");
 return resourceB.value + resourceA.value;
                        } 
                } 
        } 

 publicvoid write(int a,int b) { 
 synchronized (resourceB) {
                        System.out.println("write():" + Thread.currentThread().getName() +"获取了resourceA的锁!");
 synchronized (resourceA) {
                                System.out.println("write():" + Thread.currentThread().getName() +"获取了resourceB的锁!");
                                resourceA.value = a; 
                                resourceB.value = b; 
                        } 
                } 
        } 
}

下面死锁的情况发生了,真是难得一见啊:

Java线程:volatile关键字

Java™ 语言包含两种内在的同步机制:同步块(或方法)和 volatile变量。这两种机制的提出都是为了实现代码线程的安全性。其中 Volatile变量的同步性较差(但有时它更简单并且开销更低),而且其使用也更容易出错。

谈及到volatile关键字,不得不提的一篇文章是:《Java理论与实践:正确使用 Volatile 变量》,这篇文章对volatile关键字的用法做了相当精辟的阐述。

之所以要单独提出volatile这个不常用的关键字原因是这个关键字在高性能的多线程程序中也有很重要的用途,只是这个关键字用不好会出很多问题。

首先考虑一个问题,为什么变量需要volatile来修饰呢?

要搞清楚这个问题,首先应该明白计算机内部都做什么了。比如做了一个i++操作,计算机内部做了三次处理:读取-修改-写入。

同样,对于一个long型数据,做了个赋值操作,在32系统下需要经过两步才能完成,先修改低32位,然后修改高32位。

假想一下,当将以上的操作放到一个多线程环境下操作时候,有可能出现的问题,是这些步骤执行了一部分,而另外一个线程就已经引用了变量值,这样就导致了读取脏数据的问题。

通过这个设想,就不难理解volatile关键字了。

volatile可以用在任何变量前面,但不能用于final变量前面,因为final型的变量是禁止修改的。也不存在线程安全的问题。

更多的内容,请参看::《Java理论与实践:正确使用 Volatile 变量》一文,写得很好

Java线程:新特征-线程池

Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序,线程部分的新增内容显得尤为重要。

有关Java5线程新特征的内容全部在java.util.concurrent下面,里面包含数目众多的接口和类,熟悉这部分API特征是一项艰难的学习过程。目前有关这方面的资料和书籍都少之又少,大所属介绍线程方面书籍还停留在java5之前的知识层面上。

当然新特征对做多线程程序没有必须的关系,在java5之前通用可以写出很优秀的多线程程序。只是代价不一样而已。

线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程对象所带来的性能开销,节省了系统的资源。

在Java5之前,要实现一个线程池是相当有难度的,现在Java5为我们做好了一切,我们只需要按照提供的API来使用,即可享受线程池带来的极大便利。

Java5的线程池分好多种:固定尺寸的线程池、可变尺寸连接池。

在使用线程池之前,必须知道如何去创建一个线程池,在Java5中,需要了解的是java.util.concurrent.Executors类的API,这个类提供大量创建连接池的静态方法,是必须掌握的。

一、固定大小的线程池

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

/** 
* Java线程:线程池- 
* 
* @author Administrator 2009-11-4 23:30:44 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
 //创建一个可重用固定线程数的线程池
                ExecutorService pool = Executors.newFixedThreadPool(2); 
 //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
                Thread t1 = new MyThread();
                Thread t2 = new MyThread();
                Thread t3 = new MyThread();
                Thread t4 = new MyThread();
                Thread t5 = new MyThread();
 //将线程放入池中进行执行
                pool.execute(t1); 
                pool.execute(t2); 
                pool.execute(t3); 
                pool.execute(t4); 
                pool.execute(t5); 
 //关闭线程池
                pool.shutdown(); 
        } 
} 

class MyThread extends Thread{ 
        @Override 
 publicvoid run() {
                System.out.println(Thread.currentThread().getName()+"正在执行。。。");
        } 
}
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。

Process finished with exit code 0

二、单任务线程池

在上例的基础上改一行创建pool对象的代码为:

//创建一个使用单个 worker线程的 Executor,以无界队列方式来运行该线程。 ExecutorService pool = Executors.newSingleThreadExecutor();

输出结果为:

pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 Process finished with exit code 0

对于以上两种连接池,大小都是固定的,当要加入的池的线程(或者任务)超过池最大尺寸时候,则入此线程池需要排队等待。

一旦池中有线程完毕,则排队等待的某个线程会入池执行。

三、可变尺寸的线程池

与上面的类似,只是改动下pool的创建方式:

//创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。 ExecutorService pool = Executors.newCachedThreadPool();

pool-1-thread-5正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-4正在执行。。。 pool-1-thread-3正在执行。。。 pool-1-thread-2正在执行。。。 Process finished with exit code 0

四、延迟连接池

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/** 
* Java线程:线程池- 
* 
* @author Administrator 2009-11-4 23:30:44 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
 //创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。
                ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
 //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
                Thread t1 = new MyThread();
                Thread t2 = new MyThread();
                Thread t3 = new MyThread();
                Thread t4 = new MyThread();
                Thread t5 = new MyThread();
 //将线程放入池中进行执行
                pool.execute(t1); 
                pool.execute(t2); 
                pool.execute(t3); 
 //使用延迟执行风格的方法
                pool.schedule(t4, 10, TimeUnit.MILLISECONDS); 
                pool.schedule(t5, 10, TimeUnit.MILLISECONDS); 
 //关闭线程池
                pool.shutdown(); 
        } 
} 

class MyThread extends Thread { 
        @Override 
 publicvoid run() {
                System.out.println(Thread.currentThread().getName() + "正在执行。。。");
        } 
}
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。

Process finished with exit code 0
五、单任务延迟连接池
在四代码基础上,做改动
 //创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
 ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。

Process finished with exit code 0

六、自定义线程池

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/** 
* Java线程:线程池-自定义线程池
* 
* @author Administrator 2009-11-4 23:30:44 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
 //创建等待队列
                BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
 //创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
                ThreadPoolExecutor pool = newThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);
 //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
                Thread t1 = new MyThread();
                Thread t2 = new MyThread();
                Thread t3 = new MyThread();
                Thread t4 = new MyThread();
                Thread t5 = new MyThread();
                Thread t6 = new MyThread();
                Thread t7 = new MyThread();
 //将线程放入池中进行执行
                pool.execute(t1); 
                pool.execute(t2); 
                pool.execute(t3); 
                pool.execute(t4); 
                pool.execute(t5); 
                pool.execute(t6); 
                pool.execute(t7); 
 //关闭线程池
                pool.shutdown(); 
        } 
} 

class MyThread extends Thread { 
        @Override 
 publicvoid run() {
                System.out.println(Thread.currentThread().getName() + "正在执行。。。");
 try {
                        Thread.sleep(100L); 
                } catch (InterruptedException e) {
                        e.printStackTrace(); 
                } 
        } 
}
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。

Process finished with exit code 0

创建自定义线程池的构造方法很多,本例中参数的含义如下:

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,
 long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue)

用给定的初始参数和默认的线程工厂及处理程序创建新的ThreadPoolExecutor。使用Executors工厂方法之一比使用此通用构造方法方便得多。

参数:

corePoolSize -池中所保存的线程数,包括空闲线程。

maximumPoolSize -池中允许的最大线程数。

keepAliveTime -当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。

unit - keepAliveTime参数的时间单位。

workQueue -执行前用于保持任务的队列。此队列仅保持由execute方法提交的Runnable任务。

抛出:

IllegalArgumentException -如果 corePoolSize或 keepAliveTime小于零,或者 maximumPoolSize小于或等于零,或者 corePoolSize大于 maximumPoolSize。

NullPointerException -如果workQueue为 null

自定义连接池稍微麻烦些,不过通过创建的ThreadPoolExecutor线程池对象,可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。

有关Java5线程池的内容到此就没有了,更多的内容还需要研读API来获取。

Java线程:新特征-有返回值的线程

在Java5之前,线程是没有返回值的,常常为了“有”返回值,破费周折,而且代码很不好写。或者干脆绕过这道坎,走别的路了。

现在Java终于有可返回值的任务(也可以叫做线程)了。

可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。

执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了。

下面是个很简单的例子:

import java.util.concurrent.*;

/** 
* Java线程:有返回值的线程
* 
* @author Administrator 2009-11-5 0:41:50 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args)throws ExecutionException, InterruptedException {
 //创建一个线程池
                ExecutorService pool = Executors.newFixedThreadPool(2); 
 //创建两个有返回值的任务
                Callable c1 = new MyCallable("A");
                Callable c2 = new MyCallable("B");
 //执行任务并获取Future对象
                Future f1 = pool.submit(c1); 
                Future f2 = pool.submit(c2); 
 //从Future对象上获取任务的返回值,并输出到控制台
                System.out.println(">>>"+f1.get().toString());
                System.out.println(">>>"+f2.get().toString());
 //关闭线程池
                pool.shutdown(); 
        } 
} 

class MyCallableimplements Callable{
 private String oid;

        MyCallable(String oid) { 
 this.oid = oid;
        } 

        @Override 
 public Object call()throws Exception {
 return oid+"任务返回的内容";
        } 
}
>>>A任务返回的内容
>>>B任务返回的内容 

Process finished with exit code 0 

非常的简单,要深入了解还需要看Callable和Future接口的API啊。

Java线程:新特征-锁(上)

在Java5中,专门提供了锁对象,利用锁可以方便的实现资源的封锁,用来控制对竞争资源并发访问的控制,这些内容主要集中在java.util.concurrent.locks包下面,里面有三个重要的接口Condition、Lock、ReadWriteLock。

Condition

Condition将Object监视器方法(wait、notify和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意Lock实现组合使用,为每个对象提供多个等待 set(wait-set)。

Lock

Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。

ReadWriteLock

ReadWriteLock维护了一对相关的锁定,一个用于只读操作,另一个用于写入操作。

有关锁的介绍,API文档解说很多,看得很烦,还是看个例子再看文档比较容易理解。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/** 
* Java线程:锁 
* 
* @author leizhimin 2009-11-5 10:57:29 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
 //创建并发访问的账户
                MyCount myCount = new MyCount("95599200901215522", 10000);
 //创建一个锁对象
                Lock lock = new ReentrantLock();
 //创建一个线程池
                ExecutorService pool = Executors.newCachedThreadPool(); 
 //创建一些并发访问用户,一个信用卡,存的存,取的取,好热闹啊
                User u1 = new User("张三", myCount, -4000, lock); 
                User u2 = new User("张三他爹", myCount, 6000, lock); 
                User u3 = new User("张三他弟", myCount, -8000, lock); 
                User u4 = new User("张三", myCount, 800, lock);
 //在线程池中执行各个用户的操作
                pool.execute(u1); 
                pool.execute(u2); 
                pool.execute(u3); 
                pool.execute(u4); 
 //关闭线程池
                pool.shutdown(); 
        } 
} 

/** 
* 信用卡的用户 
*/ 
class User implements Runnable { 
 private String name;                //用户名
 private MyCount myCount;        //所要操作的账户
 privateint iocash;                //操作的金额,当然有正负之分了
 private Lock myLock;                //执行操作所需的锁对象

        User(String name, MyCount myCount, int iocash, Lock myLock) {
 this.name = name;
 this.myCount = myCount;
 this.iocash = iocash;
 this.myLock = myLock;
        } 

 publicvoid run() {
 //获取锁
                myLock.lock(); 
 //执行现金业务
                System.out.println(name + "正在操作" + myCount +"账户,金额为" + iocash +",当前金额为" + myCount.getCash());
                myCount.setCash(myCount.getCash() + iocash); 
                System.out.println(name + "操作" + myCount +"账户成功,金额为" + iocash +",当前金额为" + myCount.getCash());
 //释放锁,否则别的线程没有机会执行了
                myLock.unlock(); 
        } 
} 

/** 
* 信用卡账户,可随意透支 
*/ 
class MyCount { 
 private String oid;        //账号
 privateint cash;            //账户余额

        MyCount(String oid, int cash) {
 this.oid = oid;
 this.cash = cash;
        } 

 public String getOid() {
 return oid;
        } 

 publicvoid setOid(String oid) {
 this.oid = oid;
        } 

 publicint getCash() {
 return cash;
        } 

 publicvoid setCash(int cash) {
 this.cash = cash;
        } 

        @Override 
 public String toString() {
 return"MyCount{" +
 "oid='" + oid + '\'' +
 ", cash=" + cash +
                                '}'; 
        } 
}
张三正在操作MyCount{oid='95599200901215522', cash=10000}账户,金额为-4000,当前金额为10000
张三操作MyCount{oid='95599200901215522', cash=6000}账户成功,金额为-4000,当前金额为6000
张三他爹正在操作MyCount{oid='95599200901215522', cash=6000}账户,金额为6000,当前金额为6000
张三他爹操作MyCount{oid='95599200901215522', cash=12000}账户成功,金额为6000,当前金额为12000
张三他弟正在操作MyCount{oid='95599200901215522', cash=12000}账户,金额为-8000,当前金额为12000
张三他弟操作MyCount{oid='95599200901215522', cash=4000}账户成功,金额为-8000,当前金额为4000
张三正在操作MyCount{oid='95599200901215522', cash=4000}账户,金额为800,当前金额为4000
张三操作MyCount{oid='95599200901215522', cash=4800}账户成功,金额为800,当前金额为4800

Process finished with exit code 0

从上面的输出可以看到,利用锁对象太方便了,比直接在某个不知情的对象上用锁清晰多了。

但一定要注意的是,在获取了锁对象后,用完后应该尽快释放锁,以便别的等待该锁的线程有机会去执行。

Java线程:新特征-锁(下)

在上文中提到了Lock接口以及对象,使用它,很优雅的控制了竞争资源的安全访问,但是这种锁不区分读写,称这种锁为普通锁。为了提高性能,Java提供了读写锁,在读的地方使用读锁,在写的地方使用写锁,灵活控制,在一定程度上提高了程序的执行效率。

Java中读写锁有个接口java.util.concurrent.locks.ReadWriteLock,也有具体的实现ReentrantReadWriteLock,详细的API可以查看JavaAPI文档。

下面这个例子是在文例子的基础上,将普通锁改为读写锁,并添加账户余额查询的功能,代码如下:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/** 
* Java线程:锁 
* 
* @author leizhimin 2009-11-5 10:57:29 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
 //创建并发访问的账户
                MyCount myCount = new MyCount("95599200901215522", 10000);
 //创建一个锁对象
                ReadWriteLock lock = new ReentrantReadWriteLock(false);
 //创建一个线程池
                ExecutorService pool = Executors.newFixedThreadPool(2); 
 //创建一些并发访问用户,一个信用卡,存的存,取的取,好热闹啊
                User u1 = new User("张三", myCount, -4000, lock, false); 
                User u2 = new User("张三他爹", myCount, 6000, lock, false); 
                User u3 = new User("张三他弟", myCount, -8000, lock, false); 
                User u4 = new User("张三", myCount, 800, lock,false); 
                User u5 = new User("张三他爹", myCount, 0, lock,true); 
 //在线程池中执行各个用户的操作
                pool.execute(u1); 
                pool.execute(u2); 
                pool.execute(u3); 
                pool.execute(u4); 
                pool.execute(u5); 
 //关闭线程池
                pool.shutdown(); 
        } 
} 

/** 
* 信用卡的用户 
*/ 
class User implements Runnable { 
 private String name;                //用户名
 private MyCount myCount;        //所要操作的账户
 privateint iocash;                //操作的金额,当然有正负之分了
 private ReadWriteLock myLock;                //执行操作所需的锁对象
 privateboolean ischeck;        //是否查询

        User(String name, MyCount myCount, int iocash, ReadWriteLock myLock,boolean ischeck) {
 this.name = name;
 this.myCount = myCount;
 this.iocash = iocash;
 this.myLock = myLock;
 this.ischeck = ischeck;
        } 

 publicvoid run() {
 if (ischeck) {
 //获取读锁
                        myLock.readLock().lock(); 
                        System.out.println("读:" + name +"正在查询" + myCount +"账户,当前金额为" + myCount.getCash());
 //释放读锁
                        myLock.readLock().unlock(); 
                } else {
 //获取写锁
                        myLock.writeLock().lock(); 
 //执行现金业务
                        System.out.println("写:" + name +"正在操作" + myCount +"账户,金额为" + iocash +",当前金额为" + myCount.getCash());
                        myCount.setCash(myCount.getCash() + iocash); 
                        System.out.println("写:" + name +"操作" + myCount +"账户成功,金额为" + iocash +",当前金额为" + myCount.getCash());
 //释放写锁
                        myLock.writeLock().unlock(); 
                } 
        } 
} 

/** 
* 信用卡账户,可随意透支 
*/ 
class MyCount { 
 private String oid;        //账号
 privateint cash;            //账户余额

        MyCount(String oid, int cash) {
 this.oid = oid;
 this.cash = cash;
        } 

 public String getOid() {
 return oid;
        } 

 publicvoid setOid(String oid) {
 this.oid = oid;
        } 

 publicint getCash() {
 return cash;
        } 

 publicvoid setCash(int cash) {
 this.cash = cash;
        } 

        @Override 
 public String toString() {
 return"MyCount{" +
 "oid='" + oid + '\'' +
 ", cash=" + cash +
                                '}'; 
        } 
}
写:张三正在操作MyCount{oid='95599200901215522', cash=10000}账户,金额为-4000,当前金额为10000
写:张三操作MyCount{oid='95599200901215522', cash=6000}账户成功,金额为-4000,当前金额为6000
写:张三他弟正在操作MyCount{oid='95599200901215522', cash=6000}账户,金额为-8000,当前金额为6000
写:张三他弟操作MyCount{oid='95599200901215522', cash=-2000}账户成功,金额为-8000,当前金额为-2000
写:张三正在操作MyCount{oid='95599200901215522', cash=-2000}账户,金额为800,当前金额为-2000
写:张三操作MyCount{oid='95599200901215522', cash=-1200}账户成功,金额为800,当前金额为-1200
读:张三他爹正在查询MyCount{oid='95599200901215522', cash=-1200}账户,当前金额为-1200
写:张三他爹正在操作MyCount{oid='95599200901215522', cash=-1200}账户,金额为6000,当前金额为-1200
写:张三他爹操作MyCount{oid='95599200901215522', cash=4800}账户成功,金额为6000,当前金额为4800

Process finished with exit code 0

在实际开发中,最好在能用读写锁的情况下使用读写锁,而不要用普通锁,以求更好的性能。

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2017-12-12

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏用户2442861的专栏

Base64编码原理与应用

2015年,我们在青云平台上实现了“百度云观测”应用。青云应用本质上是一个iframe,在向iframe服务方发送的请求中会携带一些数据,青云平台会使用Bas...

14820
来自专栏静晴轩

Java 中的并发

如何创建一个线程 按 Java 语言规范中的说法,创建线程只有一种方式,就是创建一个 Thread 对象。而从 HotSpot 虚拟机的角度看,创建一个虚拟机...

34960
来自专栏日常分享

Java 线程池的实现

        任务接口:每个任务必须实现的接口,主要用来规定任务的入口、任务执行完后的收尾工作、任务的执行状态等。 工作线程通过该接口调度任务的执行。

18950
来自专栏Java后端技术栈

Java 虚拟机内存区域划分详解(1)

JVM,java virtual machine, 即Java虚拟机,是运行java class文件的程序。

11340
来自专栏Android中高级开发

Android并发编程 多线程与锁

该文章是一个系列文章,是本人在Android开发的漫漫长途上的一点感想和记录,如果能给各位看官带来一丝启发或者帮助,那真是极好的。

12460
来自专栏禁心尽力

多线程编程:阻塞、并发队列的使用总结

最近,一直在跟设计的任务调度模块周旋,目前终于完成了第一阶段的调试。今天,我想借助博客园平台把最近在设计过程中,使用队列和集合的一些基础知识给大家总结一下,方便...

27450
来自专栏腾讯Bugly的专栏

Android Linker 与 SO 加壳技术

1. 前言 Android 系统安全愈发重要,像传统pc安全的可执行文件加固一样,应用加固是Android系统安全中非常重要的一环。目前Android 应用加固...

38560
来自专栏Java大联盟

Java面试手册:线程专题 ③

13310
来自专栏企鹅号快讯

BTrace使用小结

简介 BTrace是一个安全的JVM动态追踪工具,最初为原Sun公司Kenai项目下面的一个子项目。 典型的使用场景是,“我要查个问题,可那个方法没有打印入口参...

36480
来自专栏北京马哥教育

十分钟带你了解 Python3 多线程核心知识

每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。 每个线程都有他自...

27550

扫码关注云+社区

领取腾讯云代金券