fib(N)->
P1 = spawn(fun concFib:conFib/0),
P2 = spawn(fun concFib:conFib/0),
X=rpc(P1,N-2),Y=rpc(P2,N-1),X+Y.
conFib()->
receive
{Client,N} -> Client ! regfib(N)
end.
rpc(Pid,Request)->
case erlang:is_process_alive(Pid) of
true -> begin
Pid ! {self(),Request},
receive
{Pid,Respond} -> Respond
end
end;
false -> io:format("~w process is dead.",[Pid])
end.
regfib(N)->
case N<2 of
true -> 1;
false -> regfib(N,1,1,1)
end.
regfib(N,N,X,_)-> X ;
regfib(N,M,X,Y)-> regfib(N,M+1,X+Y,X).
想法是将fib(N)过程分成两个过程,一个计算fib(N-2),另一个计算calc.fib(N-1)同时为fib(N)= fib(N-1)+ fib(N-2).当我运行前面的代码时,没有任何事情发生,光标在有限循环中停止或等待未到达结果.
plzzz我需要帮助我是一个新的Erlang程序员,在此先感谢:)
我目前正在编写一个程序,它将同时运行多个程序,而其他程序则自行运行.
if( WAIT_FAILED == WaitForMultipleObjects(numberOfProgramsRan, &information[i].hProcess, TRUE, INFINITE) ) {
wcerr << L"Failure waiting for process" << endl;
}
numberOfProgramsRan是我在循环中运行的程序数.
&information[i]是一个vector从创建过程中保存我的过程信息
当我在for循环中创建进程时,如果在运行我的下一个进程之前创建了两个或更少的进程(因此两个程序被传入运行),我的程序将等待.如果创建两个以上的进程(或在我的向量中传入两个以上的程序),我的WaitForMultipleObjects失败.
如果我需要进一步解释我的问题,请告诉我.
谢谢你的帮助
我需要编写类似于生产者 - 消费者的问题,必须使用信号量.我尝试了几种解决方案,但没有一种解决方案.首先,我在维基百科上尝试了一个解决方案但它没有用.我当前的代码是这样的:
消费者的方法运行:
public void run() {
int i=0;
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
String s = new String();
while (1!=2){
Date datainicio = new Date();
String inicio=dateFormat.format(datainicio);
try {
Thread.sleep(1000);///10000
} catch (InterruptedException e) {
System.out.println("Excecao InterruptedException lancada.");
}
//this.encheBuffer.down();
this.mutex.down();
// RC
i=0;
while (i<buffer.length) {
if (buffer[i] == null) {
i++;
} else {
break;
}
}
if (i<buffer.length) {
QuantidadeBuffer.quantidade--;
Date datafim = new Date();
String fim=dateFormat.format(datafim);
int identificador;
identificador=buffer[i].getIdentificador()[0];
s="Consumidor Thread: "+Thread.currentThread()+" Pedido: …我正在阅读这本书:"Java Concurrency in Practice",以更好地理解java并发的工作原理.在第3章第3.1节:可见性本书试图展示可见性问题是如何发生的.这是示例代码(书中的清单3.1):
public class NoVisibility {
private static boolean ready;
private static int number;
private static class ReaderThread extends Thread {
public void run() {
while (!ready)
Thread.yield();
System.out.println(number);
}
}
public static void main(String[] args) {
new ReaderThread().start();
number = 42;
ready = true;
}
}
该书说NoVisibility可以永远循环,因为ready的值可能永远不会对读者线程可见.怎么可能.我的一般理解是,无论如何,准备将在某个时间成为现实.但我无法理解为什么这可能不会发生并且循环永远存在.有人可以帮助我更好地理解这一点.
我正在尝试这个代码,我对我得到的输出有点困惑/惊讶.我还是Java新手,但我知道线程通常应该同时运行.看来我的"printB"线程在开始执行之前等待"printA"线程.我已经多次运行该程序(希望得到两个线程结果的混合,即类似:a,a,b,a,b,a ......)但仍然得到相同的输出(即"A"在"B"之前先打印.为什么会发生这种情况？如何更改代码以开始正常运行？
任何意见/建议将不胜感激.谢谢.
另外,我正在使用extends Thread方法尝试相同的代码,但它不起作用.
class PrintChars implements Runnable{
private char charToPrint;
private int times;
public PrintChars(char c, int t){
charToPrint = c;
times = t;
}
public void run(){
for (int i=0; i<times; i++)
System.out.println(charToPrint);
}
public static void main(String[] args){
PrintChars charA = new PrintChars('a', 7);
PrintChars charB = new PrintChars('b', 5);
Thread printA = new Thread(charA);
Thread printB = new Thread(charB);
printA.start();
printB.start();
}
}
扩展Thread方法如下:
class PrintChars extends Thread {
private Char charToPrint;
private int times; …我一直在比较Scala over Java在并发编程方面的优势.
显然,我提出的第一点是Scala是一种功能性编程语言(部分)使用FP自然避免了副作用
与命令式语言相比,函数式编程中如何避免副作用以及它如何在多线程/并发编程中工作？
multithreading functional-programming scala concurrent-programming
我正在Clojure中实现一个音乐编程语言解析器.我们的想法是使用文本文件作为命令行参数运行解析器程序; 文本文件包含我正在开发的这种音乐语言的代码; 解析器解释代码并确定声明了什么"工具实例",并且对于每个工具实例,它解析代码并返回一系列音乐"事件"(音符,和弦,休止符等). .所以在最后一步之前,我们有多个"音乐代码"字符串,每个乐器实例一个字符串.
我对Clojure有点新,并且仍在学习如何使用引用类型和线程/并发的细微差别.我的解析器将进行一些复杂的解析,因此我认为使用并发来提高性能会受益.这是我的问题:
看来,最简单的方法是在初始解析(单线程操作)将文档"拆分"之后保存并发性,然后同时在不同的线程上解析每个工具的代码(而不是等到每个乐器完成解析,然后再移动到下一个).我是在正确的轨道上,还是有更有效和/或逻辑的方式来构建我的"并发计划"？
对于如何实现此并发解析,以及从性能或代码维护的角度来看,哪个可能最佳？看起来它可能很简单:(map #(future (process-music-code %)) instrument-instances)但是我不确定是否有更好的方法来执行它,例如使用代理,或通过Java互操作的手动线程,或者什么.我是并发编程的新手,所以不同方法的任何输入都会很棒.
从我所看到的,似乎Clojure的引用类型在并发编程中起着重要作用,我可以看到原因,但是在使用多个线程时是否总是需要使用它们？我是否应该担心我的一些数据是否可变？如果是这样,我正在编写的解析器的代码中应该是什么特别可变的？什么参考类型最适合我正在做的事情？我的程序工作方式的本质(用户以文本文件作为参数运行程序 - 程序处理它并将其转换为音频)使得看起来我不需要任何可变的东西,因为输入数据永远不会改变,所以我的直觉告诉我我不需要使用任何引用类型,但话说再说一遍,我可能不完全理解引用类型和Clojure中的并发性之间的关系.
multithreading clojure reference-type concurrent-programming
我正在调用100个线程,每个线程应该将共享变量增加1000次.所以预期的输出应该是100000.当然,当多个线程试图增加一个共享变量时,你也可以获得不是100000的输出(你不太可能得到100000).
为了解决这个问题,我在方法中加了一个锁来增加变量,以便一切都能同步运行.
但是,我仍然得到99000,98000,有时甚至是100000这样的数字.但它应该总是100000,因为我有一个锁定权利？
这就是我所拥有的
volatile unsigned int count = 0;
void *increment(void *vargp);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main() {
fprintf(stdout, "Before: count = %d\n", count);
int j;
// run 10 times to test output
for (j = 0; j < 10; j++) {
// reset count every time
count = 0;
int i;
// create 100 theads
for (i = 0; i < 100; i++) {
pthread_t thread;
Pthread_create(&thread, NULL, increment, NULL);
}
fprintf(stdout, "After: count = %d\n", count); …我有以下顺序代码,使用另一个键列表从哈希映射中删除条目.地图大小可以是50-100k条目,删除密钥列表可以是2k - 10k.我正在寻找使用新的java-8流的解决方案......
List<Long> removed = new ArrayList<Long>();
for (Long k : removelist) {
if (null != map.remove(k)) {
removed.add(k);
}
}