JAVA开发面试题&多线程篇&第二部分
1volatile关键字是否能保证线程安全?
答:不能。虽然volatile提供了同步的机制,但是只是一种弱的同步机制,如需要强线程安全,还需要使用synchronized。
Java语言提供了一种稍弱的同步机制,即volatile变量,用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的,因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方,因此在读取volatile类型的变量时总会返回最新写入的值。
一、volatile的内存语义是:
当写
一个volatile变量时,JMM会把该线程对应的本地内存中的共享变量值立即刷新到主内存中。
当读
一个volatile变量时,JMM会把该线程对应的本地内存设置为无效,直接从主内存中读取共享变量。
二、volatile底层的实现机制
如果把加入volatile关键字的代码和未加入volatile关键字的代码都生成汇编代码,会发现加入volatile关键字的代码会多出一个lock前缀指令。
1 、重排序时不能把后面的指令重排序到内存屏障之前的位置
2、使得本CPU的Cache写入内存
3、写入动作也会引起别的CPU或者别的内核无效化其Cache,相当于让新写入的值对别的线程可见。
2请写出常用的Java多线程启动方式,Executors线程池有几种常用类型?
(1) 继承Thread类
public class java_thread extends Thread{
public static void main(String args[]) {
new java_thread().run();
System.out.println("main thread run ");
}
public synchronized void run() {
System.out.println("sub thread run ");
}
}
(2) 实现Runnable接口
public class java_thread implements Runnable{
public static void main(String args[]) {
new Thread(new java_thread()).start();
System.out.println("main thread run ");
}
public void run() {
System.out.println("sub thread run ");
}
}
在Executor框架下,利用Executors的静态方法可以创建三种类型的常用线程池:
1)FixedThreadPool这个线程池可以创建固定线程数的线程池。
2)SingleThreadExecutor是使用单个worker线程的Executor。
3)CachedThreadPool是一个”无限“容量的线程池,它会根据需要创建新线程。
3关于sleep()和wait(),以下描述错误的一项是()
选项 | 内容 |
---|---|
A | sleep是线程类(Thread)的方法,wait是Object类的方法 |
B | Sleep不释放对象锁,wait放弃对象锁 |
C | Sleep暂停线程、但监控状态任然保持,结束后会自动恢复 |
D | Wait后进入等待锁定池,只针对此对象发出notify方法后获取对象锁进入运行状态。 |
答案:D
分析:针对此对象的notify方法后获取对象锁并进入就绪状态,而不是运行状态。另外针对此对象的notifyAll方法后也可能获取对象锁并进入就绪状态,而不是运行状态
4进程和线程的区别是什么?
进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
区别 | 进程 | 进程 |
---|---|---|
根本区别 | 作为资源分配的单位 | 调度和执行的单位 |
开销 | 每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销。 | 线程可以看成时轻量级的进程,同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换的开销小。 |
所处环境 | 系统在运行的时候会为每个进程分配不同的内存区域 | 除了CPU之外,不会为线程分配内存(线程所使用的资源是它所属的进程的资源),线程组只能共享资源 |
分配内存 | 系统在运行的时候会为每个进程分配不同的内存区域 | 除了CPU之外,不会为线程分配内存(线程所使用的资源是它所属的进程的资源),线程组只能共享资源 |
包含关系 | 没有线程的进程是可以被看作单线程的,如果一个进程内拥有多个线程,则执行过程不是一条线的,而是多条线(线程)共同完成的。 | 线程是进程的一部分,所以线程有的时候被称为是轻权进程或者轻量级进程。 |
5创建n多个线程,如何保证这些线程同时启动?看清,是“同时”。
答:用一个for循环创建线程对象,同时调用wait()方法,让所有线程等待;直到最后一个线程也准备就绪后,调用notifyAll(), 同时启动所有线程。
比如:给你n个赛车,让他们都在起跑线上就绪后,同时出发,Java多线程如何写代码?
思路是,来一辆赛车就加上一把锁,并修改对应的操作数,如果没有全部就绪就等待,并释放锁,直到最后一辆赛车到场后唤醒所有的赛车线程。代码参考如下:
public class CarCompetion {
// 参赛赛车的数量
protected final int totalCarNum = 10;
// 当前在起跑线的赛车数量
protected int nowCarNum = 0;
}
public class Car implements Runnable{
private int carNum;
private CarCompetion competion = null;
public Car(int carNum, CarCompetion competion) {
this.carNum = carNum;
this.competion = competion;
}
@Override
public void run() {
synchronized (competion) {
competion.nowCarNum++;
while (competion.nowCarNum < competion.totalCarNum) {
try {
competion.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
competion.notifyAll();
}
startCar();
}
private void startCar() {
System.out.println("Car num " + this.carNum + " start to run.");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Car num " + this.carNum + " get to the
finish line.");
}
}
public static void main(String[] args) {
CarCompetion carCompetion = new CarCompetion();
final ExecutorService carPool =
Executors.newFixedThreadPool(carCompetion.totalCarNum);
for (int i = 0; i < carCompetion.totalCarNum; i++) {
carPool.execute(new Car(i, carCompetion));
}
6同步和异步有何异同,在什么情况下分别使用它们?
答:1.如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取。
2.当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。
3.举个例子: 打电话是同步 发消息是异步
7Java线程中,sleep()和wait()区别
答:sleep是线程类(Thread)的方法;作用是导致此线程暂停执行指定时间,给执行机会给其他线程,但是监控状态依然保持,到时后会自动恢复;调用sleep()不会释放对象锁。
wait是Object类的方法;对此对象调用wait方法导致本线程放弃对象锁,进入等 待此对象的等待锁定池。只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池,准备获得对象锁进行运行状态。
8sleep()和yield()有什么区别?
答:① sleep()方法给其他线程运行机会时不考虑线程的优先级,因此会给低优先级的线程以运行的机会;yield()方法只会给相同优先级或更高优先级的线程以运行的机会;
② 线程执行sleep()方法后转入阻塞(blocked)状态,而执行yield()方法后转入就绪(ready)状态;
③ sleep()方法声明抛出InterruptedException,而yield()方法没有声明任何异常;
④ sleep()方法比yield()方法(跟操作系统相关)具有更好的可移植性。
9请说出与线程同步相关的方法。
答:1. wait():使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁;
2. sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉InterruptedException 异常;
3. notify():唤醒一个处于等待状态的线程,当然在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且与优先级无关;
4. notityAll():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争;
5. JDK 1.5通过Lock接口提供了显式(explicit)的锁机制,增强了灵活性以及对线程的协调。Lock接口中定义了加锁(lock())和解锁(unlock())的方法,同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象;
6. JDK 1.5还提供了信号量(semaphore)机制,信号量可以用来限制对某个共享资源进行访问的线程的数量。在对资源进行访问之前,线程必须得到信号量的许可(调用Semaphore对象的acquire()方法);在完成对资源的访问后,线程必须向信号量归还许可(调用Semaphore对象的release()方法)。
下面的例子演示了100个线程同时向一个银行账户中存入1元钱,在没有使用同步机制和使用同步机制情况下的执行情况。
银行账户类:
package com.bjsxt;
/**
* 银行账户
* @author
*
*/
public class Account {
private double balance; // 账户余额
/**
* 存款
* @param money 存入金额
*/
public void deposit(double money) {
double newBalance = balance + money;
try {
Thread.sleep(10); // 模拟此业务需要一段处理时间
}
catch(InterruptedException ex) {
ex.printStackTrace();
}
balance = newBalance;
}
/**
* 获得账户余额
*/
public double getBalance() {
return balance;
}
}
存钱线程类:
package com.bjsxt;
/**
* 存钱线程
* @author
*
*/
public class AddMoneyThread implements Runnable {
private Account account; // 存入账户
private double money; // 存入金额
public AddMoneyThread(Account account, double money) {
this.account = account;
this.money = money;
}
@Override
public void run() {
account.deposit(money);
}
}
测试类:
package com.bjsxt;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test01 {
public static void main(String[] args) {
Account account = new Account();
ExecutorService service = Executors.newFixedThreadPool(100);
for(int i = 1; i <= 100; i++) {
service.execute(new AddMoneyThread(account, 1));
}
service.shutdown();
while(!service.isTerminated()) {}
System.out.println("账户余额: " + account.getBalance());
}
}
在没有同步的情况下,执行结果通常是显示账户余额在10元以下,出现这种状况的原因是,当一个线程A试图存入1元的时候,另外一个线程B也能够进入存款的方法中,线程B读取到的账户余额仍然是线程A存入1元钱之前的账户余额,因此也是在原来的余额0上面做了加1元的操作,同理线程C也会做类似的事情,所以最后100个线程执行结束时,本来期望账户余额为100元,但实际得到的通常在10元以下。解决这个问题的办法就是同步,当一个线程对银行账户存钱时,需要将此账户锁定,待其操作完成后才允许其他的线程进行操作,代码有如下几种调整方案:
- 在银行账户的存款(deposit)方法上同步(synchronized)关键字
package com.bjsxt;
/**
* 银行账户
* @author
*/
public class Account {
private double balance; // 账户余额
/**
* 存款
* @param money 存入金额
*/
public synchronized void deposit(double money) {
double newBalance = balance + money;
try {
Thread.sleep(10); // 模拟此业务需要一段处理时间
}
catch(InterruptedException ex) {
ex.printStackTrace();
}
balance = newBalance;
}
/**
* 获得账户余额
*/
public double getBalance() {
return balance;
}
}
- 在线程调用存款方法时对银行账户进行同步
package com.bjsxt;
/**
* 存钱线程
* @author
*
*/
public class AddMoneyThread implements Runnable {
private Account account; // 存入账户
private double money; // 存入金额
public AddMoneyThread(Account account, double money) {
this.account = account;
this.money = money;
}
@Override
public void run() {
synchronized (account) {
account.deposit(money);
}
}
}
- 通过JDK 1.5显示的锁机制,为每个银行账户创建一个锁对象,在存款操作进行加锁和解锁的操作
package com.bjsxt;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 银行账户
*
* @author
*
*/
public class Account {
private Lock accountLock = new ReentrantLock();
private double balance; // 账户余额
/**
* 存款
*
* @param money
* 存入金额
*/
public void deposit(double money) {
accountLock.lock();
try {
double newBalance = balance + money;
try {
Thread.sleep(10); // 模拟此业务需要一段处理时间
}
catch (InterruptedException ex) {
ex.printStackTrace();
}
balance = newBalance;
}
finally {
accountLock.unlock();
}
}
/**
* 获得账户余额
*/
public double getBalance() {
return balance;
}
}
按照上述三种方式对代码进行修改后,重写执行测试代码Test01,将看到最终的账户余额为100元。
10启动一个线程是用run()还是start()方法?
答:启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM 调度并执行,这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调(callback)的方法。
API解释如下: