㈠ 面试题 linux 多线程开发注意什么
注意共享数据的保护
包括动态数据，全局变量，静态局部变量等。
㈡ 哪里有关于多线程的 c#面试题
来表示
2.同步因子,在某段代码上增加同步因子,那么整个JVM内部只能最多有一个线程执行这段,其余的线程按FIFO方式等待执行.
㈢ 请教一道 Python 多线程爬虫的面试题
def saveToFile(FileName,srcList):
a=0
srcTuple = (srcList)
FileName = 'os'+FileName.strip()
res = mkdir(FileName)
if res == False:
return False
#os.mkdir(FileName)
os.chdir(FileName)
que = Queue.Queue()
for sl in srcList:
que.put(sl)
for a in range(0,srcList.__len__()):
threadD = threadDownload(que,a)
threadD.start()
#print threading.enumerate()
while threading.active_count() != 0:
if threading.active_count() == 1:
print FileName+" is Done"
return True
㈣ 一道笔试题，关于程序的调优
使用排除法应该是D，迭代和递归到底是谁效率高，看具体情况了，不能用这个做调优。回
A，属于改进缓存算法，能答提高
B，多线程并行操作可以提高速度
C，连接池减少了连接的创建和关闭对资源的损耗
E ，多次调用一次搞定，相当于减少了和外部沟通的资源损耗
F，数据共享有点缓存的味道，实际就是减少了计算和数据提取
㈤ C面试题：单线程与多线程的问题
我的天，真是啥答案都有。例子嘛……
请参见《Windows程序设计》——Charles Petzold著
北京大学回出版社，第五版
P1125
如若手头没有答书，那……我只说4个字：文件加载。自己领悟吧~~~
PS:这涉及到输入输出中断相关问题，若是不太了解底层，还是别想太深……
/////////////
另外，3楼朋友，你说的是单核，若是存在多个处理器，它们可以并发处理线程，实现真正的“并行处理”，此时线程的执行并无严格的一致顺序，因此你的解释在多个CPU共存时肯定不成立。
如果只有一个CPU，你的解释……这个跟死循环……怎么说呢，有一定关系——但我认为，这更应该属于“线程安全”的讨论范畴，与单线程/多线程的效率关系很牵强。
㈥ socket 和多线程这两部分选择面试题，哪些知识点比较能看出对方的水平
我的项目是通过Wifi和大约50台左右的设备进行通信，原先用的是多线程中使用版同步Socket的方式进行通信权，每个设备对应一个线程，线程内进行Socket收发操作，但设备一多就会出现通信阻塞的情况，导致部分设备无法及时发送数据。然后同事告诉我用异步Socket会改善很多，所以我去了解了下异步Socket，也知道该如何实现异步Socket通信，但是在了解的过程中也看到有说使用多线程同步Socket比异步Socket好
㈦ java多线程runnable和thread的区别 面试题
runnable和thread的区别（多线程必须用Runable）
Java中有两种实现多线程的方式以及两种方式之间的区别
看到一个面试题.问两种实现多线程的方法.没事去网上找了找答案.
网上流传很广的是一个网上售票系统讲解.转发过来.已经不知道原文到底是出自哪里了.
Java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？
为了回答这个问题，我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的100张车票，一个售票点用一个线程表示。
首先这样编写这个程序：
Java代码
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
"is saling ticket" + ticket--);
}else{
break;
}
}
}
}
源码打印？
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
"is saling ticket" + ticket--);
}else{
break;
}
}
}
}
main测试类:
Java代码
public class ThreadDome1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
t.start();
t.start();
t.start();
t.start();
}
}
源码打印？
public class ThreadDome1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
t.start();
t.start();
t.start();
t.start();
}
}
上面的代码中，我们用ThreadTest类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果 告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。
我们接着修改ThreadDemo1，在main方法中创建四个Thread对象：
Java代码
public class ThreadDemo1{
public static void main(String[] args){
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}
源码打印？
public class ThreadDemo1{
public static void main(String[] args){
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}
Java代码
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket" + ticket--);
}else{
break;
}
}
}
}
源码打印？
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket" + ticket--);
}else{
break;
}
}
}
}
这下达到目的了吗？
从结果上看每个票号都被打印了四次，即 四个线程各自卖各自的100张票，而不去卖共同的100张票。这种情况是怎么造成的呢？我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有100张票，每个线程都在独自处理各自的资源。
经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。
Java代码
public class ThreadDemo1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
源码打印？
public class ThreadDemo1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
Java代码
class ThreadTest implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if(tickets > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket " + tickets--);
}
}
}
}
源码打印？
class ThreadTest implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if(tickets > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket " + tickets--);
}
}
}
}
上面的程序中，创建了四个线程， 每个线程调用的是同一个ThreadTest对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。在Windows上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。
可见， 实现Runnable接口相对于继承Thread类来说，有如下显著的好处：
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。
(2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。
(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。
㈧ 一个面试题：用SSH框架做的项目是如何管理多线程的
ssh，通过action触发一个多线程任务，每个任务调用一个继承HibernateDaoSupport的service的方法，现在要每个线程都绑定一个新的hibernate session
㈨ 求教一个百度的面试题，关于多线程单例模式的
多线程的单例问题非常类似consensus问题：一堆进程进入，退出时的状态必须是第一个进内入之后的初始化容过的状态。那么用原子操作应当很容易实现。随便想了一下，用两个原子计数，一个表示对象是不是ready，另一个表示是不是正在初始化：
if (fetch(obj_ready))
{
return obj;
}
else
{
// 如果没有人在构建，就去构建
if (fetch_and_set(obj_under_build,true) == false)
{
obj = new obj();
set(obj_ready, true);
return obj;
}
// 否则退出
else
{
return nullptr;
}
}
即使不用锁，也必然有某种排它机制，因为对象正在初始化的时候是不可用的。这时候如果又有人来访问它，要么让访问者等待，要么把访问者踹出去。
㈩ 某公司面试题java11使用并发多线程加速下载文件，如何写
先建一个用于下载文件的多线程类，通常要指明下载文件的位置(URL)和文件名以及保存到本地的路径
public class FileDownloader implements Runnable
{
private static File file;//要下载的文件
private static String url;//文件所在URL
private static File storagePath;//保存路径
public static void initialize(File file, String url, File storagePath)//初始化静态字段，初始化的代码不用我写吧
}
然后，指明同步块，目的是让各个线程共享一个文件资源，那样它们可以知道同一个文件的下载状况(即获取其他线程下载文件到哪个位置，以防重复下载)
public synchronized void fileDownload()//此方法用于下载文件，一般的Java程序员都会写，实在不会我可以帮你补上
或者
public void fileDownload(){
synchronized(file){
synchronized(url){
synchronized(storagePath){
}}}}//给每个字段加上同步块
run()方法的实现就以自己的喜好去写吧，只要里面调用了fileDownload()方法就行。
public void run(){
…
fileDownload();//下载文件
…
}
然后，在主类的main方法中创建一个多线程数组:
Runnable[] fds=new FileDownloader[线程数量];//fds为file_downloaders缩写
Thread[] threads=new Thread[线程数量];
最后使用循环把所有的线程逐一启动。
for(int i=0;i<线程数量;i++){
threads[i]=new Thread(fds[i]);
threads[i].start();
}