java 线程面试题
我不知道你是不是这个意思,thread1,thread2两个线程每次让j增加1,thread3,thread4两个线程每次让j减少1,四个线程每个都调用250次相关加减一操作。最终j的结果都是100.
下面程序,总计会打印出1000个数,不管怎么样最后一个数永远是100,即j的终值永远是100,为了看中间结果运行过程我加了sleep,但无关紧要。你看看符合你要求不?
就像楼上说的,启动1000条线程不是很明白,不一致的继续讨论
package com.kalort;
public class ThreadTest
{
public static void main(String[] args)
{
Operator operator = new Operator();
Thread thread1 = new IncreaseThread(operator);
Thread thread2 = new IncreaseThread(operator);
Thread thread3 = new DecreaseThread(operator);
Thread thread4 = new DecreaseThread(operator);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}
class IncreaseThread extends Thread
{
private Operator operator;
public IncreaseThread(Operator operator)
{
this.operator = operator;
}
public void run()
{
for (int i = 0; i 250; i++)
{
try
{
Thread.sleep((long)(Math.random() * 100));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
operator.increase();
}
}
}
class DecreaseThread extends Thread
{
private Operator operator;
public DecreaseThread(Operator operator)
{
this.operator = operator;
}
public void run()
{
for (int i = 0; i 250; i++)
{
try
{
Thread.sleep((long)(Math.random() * 100));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
operator.decrease();
}
}
}
class Operator
{
private int j = 100;
public synchronized void increase()
{
while (100 != j)
{
try
{
wait(); // 如果另外线程还没减一就等待
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
j++;
System.out.println(j);
notify(); // 通知另外线程已经加一了。
}
public synchronized void decrease()
{
while (100 == j)
{
try
{
wait();
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
j–;
System.out.println(j);
notify();
}
}
Java面试题,线程的几种状态是什么
线程在执行过程中,可以处于下面几种状态:
就绪(Runnable):线程准备运行,不一定立马就能开始执行。
运行中(Running):进程正在执行线程的代码。
等待中(Waiting):线程处于阻塞的状态,等待外部的处理结束。
睡眠中(Sleeping):线程被强制睡眠。
I/O阻塞(Blocked on I/O):等待I/O操作完成。
同步阻塞(Blocked on Synchronization):等待获取锁。
死亡(Dead):线程完成了执行。
java有关线程的面试题
线程,你要弄清楚几个概念:
1、什么是线程?(进程中的子进程或从主进程中产生的子程序)
2、怎么创建线程?(继承了Thread类或实现了Runnable接口的类)
3、线程怎么运行?(抢占CPU时间,分片运行)
4、线程中同步的概念?(多个线程访问同一个对象时排队和不排队的问题)
5、线程的生命周期有哪些?(不存在-创建-运行、等待、睡眠、-死亡)
6、死锁?(A线程中用到B线程的资源,B中同时也用到A,若同时运行AB,在同步的情况下会出现A等B结束,B等A结束,这样同时无限等待)
JAVA面试题 JAVA中创建线程有几种不同的方式
第一种方式:使用Runnable接口创建线程
第二种方式:直接继承Thread类创建对象
使用Runnable接口创建线程
1.可以将CPU,代码和数据分开,形成清晰的模型
2.线程体run()方法所在的类可以从其它类中继承一些有用的属性和方法
3.有利于保持程序的设计风格一致
直接继承Thread类创建对象
1.Thread子类无法再从其它类继承(java语言单继承)。
2.编写简单,run()方法的当前对象就是线程对象,可直接操作。
在实际应用中,几乎都采取第一种方式
线程池的一些面试题
1,为什么要用线程池,优势
(1)降低资源消耗,通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
(2) 提高响应速度,当任务到达时,任务可以不需要的等到线程创建就能立即执行。
(3) 提高线程的可管理性,线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
1.1常用方式
那java中是怎样实现的线程池呢?是通过Executor框架实现的,该框架中用到了Executor,Executors,ExecutorService,ThreadPoolExecutor这几个接口或类,它们都是JUC包下的。 java.util.concurrent.Executors类是Executor的辅助类,类似于java中操作数组的辅助类java.util.Arrays,以及操作集合的java.util.Collections类
1.2:Executors类中的主要三个方法
线程安全的队列:staticQueue queue = new ConcurrentLinkedQueueString();
(1) 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中的等待,它创建的线程池corePoolSize和maximnumPoolSize是相等的,它使用的是LinkedBlockingQueue;
源码如下:
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueueRunnable());
}
(2)Executors#newSingleThreadExecutor
创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序执行,它将corePoolSize和maximnumPoolSize都设置为1,它也使用的是LinkedBlockingQueue;
源码:
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueueRunnable()));
}
(3)Executors#newCachedThreadPool
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。,它将corePoolSize设置为0,将maximnumPoolSize设置为Integer.MAX_VALUE,它使用的是SynchronousQueue,也就是说来了任务就创建线程运行,当前线程空闲超过60秒,就销毁线程;
源码:
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueueRunnable());
}
2,线程池的重要参数:
源码:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数:
corePoolSize
线程池中的常驻核心线程数,在创建了线程池后,当有请求任务来之后,就会安排池中的线程去执行请求任务,近似理解为今日当值线程,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中。
maximumPoolSize
线程池能够容纳同时执行的最大线程数,此值必须大于等于1。
keepAliveTime
多余的空闲线程的存活时间,当前线程池数量超过corePoolSize时,当空闲时间达到keepAliveTime值时,多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。
unit
keepAliveTime的单位。
workQueue
任务队列,被提交但尚未被执行的任务。
threadFactory
表示生成线程池中工作线程的线程工厂,用于创建线程一般用默认的即可。
handler
拒绝策略,表示当队列满了,再也塞不下新任务了,同时,工作线程大于等于线程池的最大线程数,无法继续为新任务服务,这时候我们就需要拒绝策略机制合理的处理这个问题,默认会抛异常, 那拒绝策略有哪些呢,我们继续往下看。
JDK内置的接口:RejectedExcutionHandle
AbortPolicy(默认)
直接抛出java.util.concurrent.RejectedExecutionException异常阻止系统正常运行,这种方式显然是不友好的。
CallerRunsPolicy
“调用者运行”一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将某些任务回退到调用者,从而降低新任务的流量。
DiscardOldestPolicy
抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交当前任务。
DiscardPolicy
直接丢弃任务,不予任何处理也不抛出异常。如果允许任务丢失,这是最好的一种解决方案。
具体选择哪一种的拒绝策略,也是看自己的系统需求了;
3,底层工作原理
(1).在创建了线程池后,等待提交过来的任务请求
(2).当调用execute()方法添加一个请求任务时,线程池会做如下判断
2.1 如果正在运行的线程数量小于corePoolSize,那么马上创建线程运行这个任务
2.2 如果正在运行的线程数量大于或等于corePoolSize,那么将这个任务放入队列
2.3 如果这时候队列满了且正在运行的线程数量还小于maximumPoolSize,那么还是要创建非核心线程立刻运行这个任务
2.4 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize,那么线程池会启动饱和拒绝策略来执行
(3). 当一个线程完成任务时,它会从队列中取下一个任务来执行
(4). 当一个线程无事可做超过一定的时间(keepAliveTime)时,线程池会判断
4.1 如果当前运行的线程数大于corePoolSize,那么这个线程就被停掉
4.2 所以线程池的所有任务完成后它最终会收缩到corePoolSize的大小
创建线程池时,配置多少线程数是合理的:
(1)CPU密集型:CPU核数+1个线程的线程池(CPU密集任务只有在真正的多核CPU上才可能得到加速)
(2)IO密集型:O密集型时,大部分线程都阻塞,故需要多配置线程数,CPU核数/1-阻塞系数 阻塞系数在0.8至0.9之间。例如4核,取个乐观值0.9,可达到40个线程左右
————————————————————————
——————————–
阿里巴巴开发手册上:出自于生产时间来说:
1,线程资源必须通过线程池提供,不能够在应用中自行创建线程;
2,线程池不允许使用Executors去创建,而是使用ThreadPoolExecutor的方式,
这样可以明确线程池的规则,规避资源耗尽的风险;
—————————
SpringBoot 自定义线程池:
1,application.yml配置:
task:
pool:
corePoolSize:5#设置核心线程数
maxPoolSize:20#设置最大线程数
keepAliveSeconds:300#设置线程活跃时间(秒)
queueCapacity:50#设置队列容量
2,线程池配置属性类:
importorg.springframework.boot.context.properties.ConfigurationProperties;
/**
* 线程池配置属性类
*/
@ConfigurationProperties(prefix =”task.pool”)
publicclassTaskThreadPoolConfig{
privateintcorePoolSize;
privateintmaxPoolSize;
privateintkeepAliveSeconds;
privateintqueueCapacity;
…getter and setter methods…
}
3,启动类上加上异步支持:
@EnableAsync
@EnableConfigurationProperties({TaskThreadPoolConfig.class} )// 开启配置属性支持
4,自定义线程池:
/**
* 创建线程池配置类
*/
@Configuration
public class TaskExecutePool {
@Autowired
private TaskThreadPoolConfig config;
/**
* 1.这种形式的线程池配置是需要在使用的方法上面@Async(“taskExecutor”),
* 2.如果在使用的方法上面不加该注解那么spring就会使用默认的线程池
* 3.所以如果加@Async注解但是不指定使用的线程池,又想自己定义线程池那么就可以重写spring默认的线程池
* 4.所以第二个方法就是重写默认线程池
* 注意:完全可以把线程池的参数写到配置文件中
*/
@Bean
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
//核心线程池大小
executor.setCorePoolSize(config.getCorePoolSize());
//最大线程数
executor.setMaxPoolSize(config.getMaxPoolSize());
//队列容量
executor.setQueueCapacity(config.getQueueCapacity());
//活跃时间
executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
//线程名字前缀
executor.setThreadNamePrefix(“TaskExecutePool-“);
// setRejectedExecutionHandler:当pool已经达到max size的时候,如何处理新任务
// CallerRunsPolicy:不在新线程中执行任务,而是由调用者所在的线程来执行
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 等待所有任务结束后再关闭线程池
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.initialize();
return executor;
}
}
测试:
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
/**
* @author qijx
*/
@Api(description = “测试控制类11111”)
@RestController
@RequestMapping(“/threadPoolController1”)
public class ThreadPoolController1 {
@Autowired
private ThreadPoolService1 threadPoolService;
@ApiOperation(value = “测试方法”)
@ResponseBody
@RequestMapping(value = “/test”,method = RequestMethod.GET)
public String threadPoolTest() {
threadPoolService.executeAsync();
return “hello word!”;
}
}
第二种方法:重写springboot线程池:
**
* 原生(Spring)异步任务线程池装配类,实现AsyncConfigurer重写他的两个方法,这样在使用默认的
* 线程池的时候就会使用自己重写的
*/
@Slf4j
@Configuration
public class NativeAsyncTaskExecutePool implements AsyncConfigurer{
//注入配置类
@Autowired
TaskThreadPoolConfig config;
@Override
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
//核心线程池大小
executor.setCorePoolSize(config.getCorePoolSize());
//最大线程数
executor.setMaxPoolSize(config.getMaxPoolSize());
//队列容量
executor.setQueueCapacity(config.getQueueCapacity());
//活跃时间
executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
//线程名字前缀
executor.setThreadNamePrefix(“NativeAsyncTaskExecutePool-“);
// setRejectedExecutionHandler:当pool已经达到max size的时候,如何处理新任务
// CallerRunsPolicy:不在新线程中执行任务,而是由调用者所在的线程来执行
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 等待所有任务结束后再关闭线程池
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.initialize();
return executor;
}
/**
* 异步任务中异常处理
* @return
*/
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return new AsyncUncaughtExceptionHandler() {
@Override
public void handleUncaughtException(Throwable arg0, Method arg1, Object… arg2) {
log.error(“==========================”+arg0.getMessage()+”=======================”, arg0);
log.error(“exception method:”+arg1.getName());
}
};
}
}
测试:
/**
* @author qijx
*/
@Service
public class ThreadPoolService2 {
private static final Logger logger = LoggerFactory.getLogger(ThreadPoolService2.class);
/**
* @Async该注解不需要在指定任何bean
*/
@Async
public void executeAsync() {
logger.info(“start executeAsync”);
try {
System.out.println(“当前运行的线程名称:” + Thread.currentThread().getName());
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
logger.info(“end executeAsync”);
}
}
————————————
Java基础面试题都有哪些?
1.java异常机制的原理与应用\x0d\x0a答:每当程序出现异常之后,如果程序没有进行相应的处理,则程序会出现中断现象。\x0d\x0a实际上,产生了异常之后,JVM会抛出一个异常类的实例化对象,如果此时使用了try语句捕获的话,则可以进行异常的处理,否则,交给JVM进行处理。当try语句捕获异常之后,将与catch语句的异常类型进行匹配,如果匹配成功则执行catch内的语句。简单的应用:在所以throws语句的地方加入try-catch。标准应用:try-catch-finally-throw-throws一起使用。 \x0d\x0a\x0d\x0a2. 垃圾回收机制的优点\x0d\x0a答:释放无用的对象所占用的空间。方式:自动回收,手动回收。使用System.gc(),实际上调用Runtime.getRuntime().gc()\x0d\x0a\x0d\x0a3. Error与Exception区别\x0d\x0a答:Error是jvm进行处理,是jvm出错\x0d\x0aexception是可以由程序处理的,可以用try-catch捕获的\x0d\x0a\x0d\x0a4. final,finally,finallize\x0d\x0a答:final定义的变量的值不能改变,定义的方法不能被覆盖,定义的类不能被继承\x0d\x0afinally是异常的统一出口,finallize是垃圾回收前的收尾工作,是Object类定义的\x0d\x0a\x0d\x0a5. Anonymous Inner Class是否可以extends,是否可以implements Interface\x0d\x0a答:允许继承和实现,因为匿名内部类就是在抽象类和接口的基础上发展起来的\x0d\x0a\x0d\x0a6. Static Nested Class 与Inner Class的区别\x0d\x0a答:使用Static定义的Class就是外部类,可以通过外部类. 内部类直接访问\x0d\x0a而Inner Class是不能被外部访问的,只能通过外部类的实例再找到内部类实例。\x0d\x0a\x0d\x0a7. HashMap and HashTable?\x0d\x0a答:HashMap:1) released in jdk 1.2,new Class 2)采用异步处理方式,性能较高,是非线程安全的 3)允许null\x0d\x0aHashTable:\x0d\x0a1)released in jdk 1.0 ,old Class \x0d\x0a2)采用同步处理方式,性能低,是线程安全的\x0d\x0a3)不允许null\x0d\x0a\x0d\x0a8. assert代表什么?\x0d\x0a答:asserts是jdk 1.4之后发布的新关键字,表示断言,即程序执行到某个地方肯定是预计的值,一般开发很少使用。要使用assert,必须加上 -ea参数\x0d\x0a\x0d\x0a9. gc是什么?\x0d\x0a答:gc是garbage collection,垃圾回收,使用gc可以进行垃圾空间的释放\x0d\x0a\x0d\x0a10. String s = new String(“xyz”)产生了几个对象?\x0d\x0a答:一个匿名对象xyz,在栈空间内。一个new实例化的对象,在堆空间内。\x0d\x0a\x0d\x0a11. sleep() and wait()?\x0d\x0a答:sleep()是Thread类定义方法,表示线程的休眠,可以自动唤醒\x0d\x0await()方法是Object类定义的方法,需要手动notify()和notifyAll()//sleep()不释放资源,wait()释放资源\x0d\x0a\x0d\x0a12. Overload与Override的区别\x0d\x0a答:Overload:重载\x0d\x0a |- 在一个类中定义的若干方法\x0d\x0a |- 所有的方法名相同,但参数类型或个数不同\x0d\x0a |- 只有参数有关,与返回类型无关\x0d\x0aOverride:覆写\x0d\x0a |- 在继承的关系中\x0d\x0a |- 子类定义了父类同名的方法,参数类型或个数最好完全一样。\x0d\x0a |- 访问权限不能更严格\x0d\x0a\x0d\x0a13. abstract class 和 interface有什么区别?\x0d\x0a答:抽象类:\x0d\x0a |-由抽象方法和常量、变量、全局常量、构造方法、普通方法组成\x0d\x0a |-使用abstract声明\x0d\x0a |-子类要通过extends继承抽象类,子类如果不是抽象类,则必须覆写抽象类的全部抽象方法\x0d\x0a |-存在单继承的局限\x0d\x0a |-抽象类可以实现若干个接口\x0d\x0a接口:\x0d\x0a |-由抽象方法和全局常量组成\x0d\x0a |-使用interface关键字\x0d\x0a |-子类要通过implements实现接口,子类如果不是抽象类,则必须覆写抽象类的全部抽象方法\x0d\x0a |-一个子类可以实现多个接口\x0d\x0a |-接口不能继承一个抽象类,但允许继承多个接口