单选题在堆栈类SharedStack的定义中，为了保证堆栈在并发操作中数据的正确性，应在下划线处填入的修饰符是（ ）。（两个下划线的填写内容相同）public class SharedStack { ______ int idx = 0; ______ char[] data = new char[10]; public synchronized void push(char c){……} public synchronized void pop(){……}}ApublicB不使用修饰符CprivateDprotected
单选题
在堆栈类SharedStack的定义中，为了保证堆栈在并发操作中数据的正确性，应在下划线处填入的修饰符是（ ）。（两个下划线的填写内容相同）public class SharedStack { ______ int idx = 0; ______ char[] data = new char[10]; public synchronized void push(char c){……} public synchronized void pop(){……}}
A
public
B
不使用修饰符
C
private
D
protected
参考解析
解析：
并发性在一定意义上可以理解为并行，即是为了保证多个线程能够进行同时放访问。因此需要保证多个线程都对其拥有访问权限。在Java语言中，其修饰符的权限如下：①public：被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。②private：被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。③protect：被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。④不使用修饰符：只允许在同一个包中进行访问。而多线程的安全性不是由这些修饰符决定的，而是由synchronized、volatile等关键字来保证。所以答案选择A。
并发性在一定意义上可以理解为并行，即是为了保证多个线程能够进行同时放访问。因此需要保证多个线程都对其拥有访问权限。在Java语言中，其修饰符的权限如下：①public：被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。②private：被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。③protect：被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。④不使用修饰符：只允许在同一个包中进行访问。而多线程的安全性不是由这些修饰符决定的，而是由synchronized、volatile等关键字来保证。所以答案选择A。
相关考题：
请使用VC6或使用【答题】菜单打开考生文件夹proj2下的工程proj2，此工程包含有一个源程序文件proj2．cpp，其中定义了Stack类和ArrayStack类。 Stack是一个用于表示数据结构“栈”的类，栈中的元素是字符型数据。Stack为抽象类，它只定义了栈的用户接口，如下所示： 公有成员函数 功能 push 入栈：在栈顶位置添加一个元素 pop 退栈：取出并返回栈顶元素 ArrayStack是Stack的派生类，它实现了Stack定义的接口。ArrayStack内部使用动态分配的字符数组作为栈元素的存储空间。数据成员maxSize表示的是栈的最大容量，top用于记录栈顶的位置。成员函数push和pop分别实现具体的入栈和退栈操作。 请在程序中的横线处填写适当的代码，然后删除横线，以实现上述功能。此程序的正确输出结果应为： a，b，C C，b，a 注意：只在指定位置编写适当代码，不要改动程序中的其他内容，也不要删除或移动“//****料found****”。 //proj2．cpp includeiostream using namespacc std； class Stack{ public： virtual void push(char C)=0； virtual char pop=0； }；class ArrayStack：public Stack{ char*P； int maxSizc； int top； public： ArravStack（int s） { top=0； maxSize=s： //*********found********* P=______； } ～ArrayStack { //*********found********* _______； } void push(char c) } if(top==maxSize){ cerr”Overflow! \n”： return； } //*********found********* _______； top++： } char pop { if(top==0){ cerr”Underflow!、n”； return‘\0’; } Top--； //*********found********* ______； } }； void f(StacksRef) { char ch[]={‘a’，‘b’，‘c’}； coutch[0]”，”ch[1]”，”ch[2]endl； sRef．push(oh[0])；sRef．push(ch[1])；sRef．push(ch[2])； coutsRef．poP”，”； coutsRef．poP”，”； coutsRef．poPendl； } int main { ArrayStack as(10)； f(as)： return 0： }
有如下程序: include using namespaee std;class Animal{ public: virtual char*g 有如下程序：include＜iostream＞using namespaee std；c lass Animal{public：virtual char*getType( )const{return"Animal"；}virtual char*getVoice( )const{return"Voice"；}}；class Dog：public Animal{public：char*getType( )const{return"Dog"；}char*getVoice( )eonst{return"Woof"；}}；void type(AnimalA) {cout＜＜a．getType( )；}void speak(Animal A) {eout＜＜a．getVoice( )；}int main( ){Dog d；type(D) ；cout＜＜"speak"；speak(D) ；cout return 0；}程序的输出结果是______。
阅读以下说明C++代码，将应填入(n)处的字句写在对应栏内。[说明]以下程序的功能是实现堆栈的一些基本操作。堆栈类stack共有三个成员函数：empty判断堆栈是否为空；push进行人栈操作；pop进行出栈操作。[C++程序]include "stdafx. h"include ＜iostream, h＞eonst int maxsize = 6;class stack {float data[ maxsize];int top;public:stuck(void);～ stack(void);bool empty(void);void push(float a);float pop(void);};stack: :stack(void){ top =0;cout ＜ ＜ "stack initialized." ＜ ＜ endl;}stack:: ～stack(void) {cout ＜ ＜" stack destoryed." ＜ ＜ endl;bool stack:: empty (void) {return (1);void stack: :push(float a)if(top= =maxsize) {cout ＜ ＜ "Stack is full!" ＜ ＜ endl;return;data[top] =a;(2);}float stack:: pop (void){ if((3)){cout＜ ＜ "Stack is undcrflow !" ＜ ＜ endl;return 0;(4);return (5);}void main( ){ stack s;coat ＜ ＜ "now push the data:";for(inti=l;i =maxsize;i+ +) {cout＜ ＜i＜ ＜" ";s. push(i);}coat ＜ ＜ endl;cout＜ ＜ "now pop the data:";for(i = 1 ;i ＜ = maxsize ;i + + )cout＜ ＜s. pop()＜ ＜" ";}
为了支持压栈线程与弹栈线程之间的交互与同步，应在下划线处填入的选项是pubIis class StackTest{private int idx=0;private int[]data=new int[8];public void push(int i){synchronized(this){______;data[idx]=i;idx++;}}……}A．this.notify()B．interrupt()C．this .wait()D．sleep()
（ 12 ）请将下面的程序补充完整，使得程序输出 “ 飘是张娜的书 ” 。#include iostreamusing namespace std;class Book{public:Book(char *str) {strcpy(title,str);}【 12 】 void PrintInfo() {couttitleendl;}protected:char title[50];};class MyBook:public Book{public:MyBook(char *s1,char *s2= " 张娜 " ):【 13 】 {strcpy(owner,s2);}virtual void PrintInfo() {couttitle " 是 " owner " 的书 " endl;}private:char owner[10];};int main(){Book *prt=new MyBook( " 飘 " );prt-PrintInfo();return 0;}
阅读下列一个支持多线程并发操作的堆栈类代码段 public class MyStack{ private int idx=0; private int[]data=new int[8]; public______void push(int i){ data[idx]=i; idx + +; } …… } 在下画线处应填入的是A．synchronizedB．waitC．blockedD．interrupt
如下程序的输出结果是______。 include using namespace std; class Pet{ char nam 如下程序的输出结果是______。include＜iostream＞using namespace std；class Pet{char name[10]；public：Pet(char*nanle){strcpy(this-＞name，name)；}const char*getName( )const{return name；}virtual void call( )eonst=0；}；class Dog：public Pet{public：Dog(char*name)：Pet(name){ }void call( )eonst{cout＜＜"汪汪叫"；}}；class Cat：public Pet{public：Cat(char*name)：Pet(name){ }void call( )const{eout＜＜"喵喵叫"；}}；int main( ){Pet*petl=new Dog("哈克")，*pet2=new Cat("吉米")；eout＜＜petl-＞getName( )；petl-＞call( )；eout＜＜endl；cout＜＜pet2-＞getName( )；pet2-＞call( )；eout＜＜endl；return 0；}
在堆栈类SharedStack的定义中，为了保证堆栈在并发操作中数据的正确性，应在下划线处填入的修饰符是(两个下划线的填写内容相同)public class SharedStack(______int idx=0;______char[]data=new char[10];public synchronized void push(char C) {......}public synchronized void pop{}{......}}A) publicB) 不使用修饰符C) privateD) protectedA．B．C．D．
本题程序中实现了一个“生产者一消费者问题”。生产者产生一个随机数存入DataPool类中，消费者从中取出数据。DataPool类一次只能存放一个数据。请更正题中带下划线的部分。注意：不改变程序的结构，不得增行或删行。class DataPool{private int data;private boolean isFull;public DataPool(){isFull=false;}public synchronized void putData(int d){if(isFull= =true){try{this.notify();}catch(InterruptedException e){}}data=d;isFull=true;System.out.println("生产了一个数据:"+data);this.notify();}public synchronized int getData(){if(isFull= =false){try{this.wait();}catch(InterruptedException e){}}isFull=false;System.out.println("消费了一个数据"+data);this.wait();return this.data;}boolean getIsFull(){return isFull;}}class Producer extends Thread{DataPool pool;public Producer(DataPool pool){this.pool=pool;}public void run(){for(int i=0; i＜10; i++){int data=(int) (Math.random()*1000);try{//用于生产数据sleep(data);}catch(InterruptedException e){}pool.putData(data);}}}class Consumer implements Runnable{DataPool pool;public Consumer(DataPool pool){this.pool=pool;}public void run(){for(int i=0; i＜10; i++){int data=pool.getData();try{//用于处理数据sleep((int) (Math.random()*1000));}catch(InterruptedException e){}}}}public class advance}public static void main(String[] args){Data Pool pool=new Data Pool();Producer pro=new Producer(pool);Runnable con=new Consumer(pool);Thread conTh=new Thread(con);&n
在堆栈类Sharedstack的定义中，为了保证堆栈在并发操作中数据的正确性，应在下画线处填人的修饰符是(两个下画线的填写内容相同)（ ）。A.puhlicB.不使用修饰符C.privateD.protected
阅读下面一个支持多线程并发操作的堆栈类代码 public class MyStack { private int idx=0； private int[] data=new int[8]; public ______ Void push(int i) { data[idx]=i； idx++； } … } 在下画线处应填入的是A．synchronizedB．waitC．blockedD．interrupt
有如下程序: include using namespace std; class Pet{ char name[10]; public: Pet(c 有如下程序：include＜iostream＞using namespace std；class Pet{char name[10]；public：Pet(char*name){strcpy(this-＞name，name);}const char*getName()const {return name;}virtual void call()const=0；}；class Dog:public Pet{public：Dog(char*name):Pet(name){}void call()const{cout＜＜"汪汪叫":}}；class Cat:public Pet{public：Cat(char*name):Pet(name){}void call()const{cout＜＜"喵喵叫";}}；int main(){Pet*pet1=new Dog("哈克")，*pet2=new Cat("吉米")；cout＜＜pet1-＞getName()；pet1-＞call()；cout＜＜end1；cout＜＜pet2-＞getName()；pet2-＞call()；cout＜＜end1；return 0；}程序的输出结果是______。
阅读下面实现堆栈类并发控制的部分代码 public class DataStack{ private int idx=0; private int[]data=new int[8]; public void push(int i){ . ________________{ data[idx]=i; idx + +; } } } …… } 在程序下画线处填入正确选项是A．synchronizedB．synchronized(this)C．synchronized()D．synchronized(idx)
为了支持压栈线程与弹栈线程之间的交互与同步，在下画线处依次填入的语句是 public class IntStack { private int idx=0； private int[]data=new int[8]； public ______ void push(int i) { data[idx]=i； idx++； ______ } … }A．synchronized() notify()B．synchronized() this.wait()C．synchronized() this.notify()D．synchronized() sleep()
以下程序运行后的输出结果是______。includeinclude usingnamespacestd;classY 以下程序运行后的输出结果是______。include ＜iostream＞include ＜string＞using namespace std;class Y;class X{int x;char *strx;public:X(int a, char *str){x=a;strx=new char[strlen(str)+1]strcpy (strx,str);}void show(Y ob);};class Y{prlvate:int y;char *stry;public:Y(int b,char *str){y=b;stry=new char[strlen(str)+1];strcpy(stry,str);}friend void X::show(Y ob);};void X::show{Y ob){cout＜＜strx＜＜",",cout＜＜ob.stry＜＜endl;}int main{{X a (10, "stringX");Y b (20, "stringY");a. show (b);renurn 0;}
有以下程序:include include using namespace std;class Y;class X{private 有以下程序： #include ＜iostream＞ #include ＜string＞ using namespace std; class Y; class X { private: int x; char *strx; public: X(int a, char *str) { x=a; strx=new char[strlen(str)+1]; strcpy(strx,str); } void show(Y ob) ; }; class Y { private: int y; char *stry; public: Y(int b,char *str) { y=b; stry=new char[strlen(str)+1]; strcpy(stry, str); } friend void X: :show(Y ob) ; }; void X: :show(Y ob) { cout＜＜strx＜＜", "; cout＜＜ob, stry＜＜end1; } int main ( ) { X a(10,"X"); Y b (20, "Y"); a. show(B) ; return 0; } 执行后的输出结果是( )。A．X,YB．a,bC．X,XD．Y,Y
为了支持压栈线程与弹栈线程之间的交互与同步，应 在下画线处填入的选项是（ ）。 public class StackTest{ private int idx=0； private int[]data=new int[8] public void push(int i){ synchronized(this){ ； data(idx)=i： idx++： } } }……A.this．notifyB.interruptC.this．waitD.sleep
为了支持压栈线程与弹栈线程之间的交互与同步，应在下画线处填入的选项是（ ）。 public class StackTest{ private int idx=0； private int[]data=new int[8] public void push(int i){ synchronized(this)( ； data(idx)=i： idx++： } } }… …A.this．notifyB.interruptC.this．waitD.sleep
为了支持压栈线程与弹栈线程之间的交互与同步，在程序的下画线处依次填入的语句是（ ）。 public class IntStack{ private int idx=0； private int[]data=new int[8]； public void push(int i){ data[idx]=i： idx++； … … }A.synchronized notifyB.synchronized this．waitC.synchronized this．notifyD.Serializable sleep
在堆栈类Sharedstack的定义中，为了保证堆栈在并发操作中数据的正确性，应在下画线处填入的修饰符是(两个下画线的填写内容相同)（ ）。 public class SharedStack{ int idx=0； char[]data=new char[10]； public synchtonized void push(char c){……} publR,synchronized void pop{……} }A.DublicB.不使用修饰符C.privateD.protected
阅读下面实现堆栈类并发控制的部分代码 public class DataStack } private int idx=0； private int[] data=new int[8]； public void push(int i) { ______ { data[idx]=I： idx++； } } … } 程序中下画线处应填入的正确选项是A．synchronizedB．synchronized(this)C．synchronized()D．synchronized(idx)
（ 31 ） 为了支持压栈线程与弹栈线程之间的交互与同步 ， 在程序的下划线处依次填入的语句是public class IntStack{private int idx=0;private int[] data=new int[8];public void push(int i){data[idx]=i;idx++;}__________......}A ） synchronized()notify()B ） synchronized()this.wait()C ） synchronized()this.notify()D ） synchronized()sleep()
以下哪个方法可以用来获得进度条的当前进度值？（）A、public synchronized int getProgress()B、public synchronized void setIndeterminate (boolean indeterminate)C、public synchronized void setProgress(int progress)D、Public final synchronized void incrementProgressBy(int diff)
class Account { private int balance； public void setBalance（int b） { balance = b； } public int getBalance（） { return balance； } public void clearBalance（） { balance = 0； } } 哪一个改变可以使 Account 类线程安全？（） A、在第2行加 synchronized 修饰符。B、在第3行加 synchronized 修饰符。C、在第3行、第4行和第6行加 synchronized 修饰符。D、在第4行、第6行和第8行加 synchronized 修饰符。
public class NamedCounter { private final String name； private int count； public NamedCounter（String name） { this.name = name； } public String getName（） { return name； } public void increment（） { coount++； } public int getCount（） { return count； } public void reset（） { count = 0； } } Which three changes should be made to adapt this class to be used safely by multiple threads？ （）A、 declare reset（） using the synchronized keywordB、 declare getName（） using the synchronized keywordC、 declare getCount（） using the synchronized keywordD、 declare the constructor using the synchronized keywordE、 declare increment（） using the synchronized keyword
public class TestFive { private int x； public void foo（） { int current = x； x = current + 1； } public void go（） { for（int i=0；i5；i++） { new Thread（） { public void run（） { foo（）； System.out.print（x + “， “）； } }.start（）； }}} Which two changes， taken together， would guarantee the output： 1， 2， 3， 4， 5， ？（）A、 Move the line 12 print statement into the foo（） method.B、 Change line 7 to public synchronized void go（） {.C、 Change the variable declaration on line 3 to private volatile int x；.D、 Wrap the code inside the foo（） method with a synchronized（ this ） block.E、 Wrap the for loop code inside the go（） method with a synchronized block synchronized（this） { // for loop code here }.
单选题class Account { private int balance； public void setBalance（int b） { balance = b； } public int getBalance（） { return balance； } public void clearBalance（） { balance = 0； } } 哪一个改变可以使 Account 类线程安全？（）A在第2行加 synchronized 修饰符。B在第3行加 synchronized 修饰符。C在第3行、第4行和第6行加 synchronized 修饰符。D在第4行、第6行和第8行加 synchronized 修饰符。