华为机试题 多线程

简介

多线程的同步是所有的公司都会使用的. 先将各种语言的放上来

code

#include <iostream>
#include <thread>
#include <mutex>
#include <string>

using namespace std;

string g;
mutex mtx;
bool stop = false;

void thread_fun1(int num) {
    while(num) {
        if(mtx.try_lock()) {
            int len = g.length();
            if(len % 4 == 0) {
                g += 'A';
                num--;
            }
            mtx.unlock();
        }
    }
    stop = true;
}


void thread_fun2() {
    while(1) {
        if(mtx.try_lock()) {
            int len = g.length();
            if (stop && len % 4 == 0) {
                mtx.unlock();
                return;
            }
            if (len % 4 == 1) {
                g += 'B';
            }
            mtx.unlock();
        }
    }
}

void thread_fun3() {
    while(1) {
        if (mtx.try_lock()) {
            int len = g.length();
            if (stop && len % 4 == 0) {
                mtx.unlock();
                return;
            }
            if (len % 4 == 2) {
                g += 'C';
            }
            mtx.unlock();
        }
    }
}

void thread_fun4() {
    while(1) {
        if (mtx.try_lock()) {
            int len = g.length();
            if (stop && len % 4 == 0) {
                mtx.unlock();
                return;
            }
            if (len % 4 == 3) {
                g += 'D';
            }
            mtx.unlock();
        }
    }
}
int main () {
    int in;
    while (cin >> in) {
        thread t1(thread_fun1, in);
        thread t2(thread_fun2);
        thread t3(thread_fun3);
        thread t4(thread_fun4);
        t1.join();
        t2.join();
        t3.join();
        t4.join();
        cout << g.c_str() << endl;
        g.clear();
        stop = false;
    }
    return 0;
}

import threading
#import time
 
class MyThread1(threading.Thread):
    def run(self):
        global g_write, mutex, ins
        #time.sleep(1)
        while ins>0:
            if mutex.acquire(1):
                if g_write[-1] == "D":
                    g_write.append("A")                    
                mutex.release()
         
class MyThread2(threading.Thread):
    def run(self):
        global g_write, mutex, ins
        #time.sleep(1)
        while ins>0:
            if mutex.acquire(1):
                if g_write[-1] == "A":
                    g_write.append("B")
                mutex.release()
         
 
class MyThread3(threading.Thread):
    def run(self):
        global g_write, mutex, ins
        while ins>0:
            if mutex.acquire(1):
                if g_write[-1] == "B":
                    g_write.append("C")
                mutex.release()
         
class MyThread4(threading.Thread):
    def run(self):
        global g_write, mutex, ins
        while ins>0:
            if mutex.acquire(1):
                if g_write[-1] == "C":
                    g_write.append("D")
                    ins -= 1
                    if ins <= 0:
                        print ''.join(g_write)
                        mutex.release()
                        break;
                mutex.release()
         

while True:
    try:
        ins = input()
    except:
        break;
    g_write = ["A"]
 
    mutex = threading.Lock()
    tsk = []
    tsk.append(MyThread1()) 
    tsk.append(MyThread2())
    tsk.append(MyThread3())
    tsk.append(MyThread4())
 
    for each in tsk:
        each.start()
    for each in tsk:
        each.join()

//借助于线程可见性变量,以及线程基本应用,完美AC
import java.util.*;
public class demo{
    public static volatile int count=0;//线程可见性变量
    public static char []buff=new char[1024*4];
    public static int index=0;
    public static  int times=10;//执行次数
    public static class CountThread extends Thread{
        public int mycount=0;
        public char ch=' ';
        public CountThread(int mycount,char ch){
            this.mycount=mycount;
            this.ch=ch;
        }
        @Override
        public void run() {
            for(int i=0;i<=times;i++){
                while(mycount!=count){
                    //自旋等待执行,不需要阻塞
                }
                buff[index]=ch;//放入缓存区
                index++;
                count=(count+1)%4;//切换到下一个线程执行
            }
        }
    }
    public static void main(String[] arg) throws Exception{
        Scanner s=new Scanner(System.in);
        while(s.hasNext()){
            index=0;//设置缓冲区索引
            count=0;
            times=s.nextInt();
            CountThread a1=new CountThread(0,'A');
            CountThread a2=new CountThread(1,'B');
            CountThread a3=new CountThread(2,'C');
            CountThread a4=new CountThread(3,'D');
            a1.start();
            a2.start();
            a3.start();
            a4.start();
            a1.join();
            a2.join();
            a3.join();
            a4.join();
            for(int i=0;i<times*4;i++)
                System.out.print(buff[i]);
            System.out.println();
        }
    }
}

//写的都什么鬼，明明要多线程。就用线程池加锁就可以的。
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
 
public class Main {
    public static void main(String[] args) throws IOException {
 
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        //Scanner in = new Scanner(System.in);
        ExecutorService service = Executors.newFixedThreadPool(4);
        String str;
 
        while((str = in.readLine()) != null) {
            int n = Integer.valueOf(str);
            for(int i = 0; i < n; i++) {
                service.execute(new MyRunnable("A", 0));
                service.execute(new MyRunnable("B", 1));
                service.execute(new MyRunnable("C", 2));
                service.execute(new MyRunnable("D", 3));
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println();
        }
        service.shutdown();
    }
    static volatile int cnt = 0;
    static ReentrantLock lock = new ReentrantLock();
    static class MyRunnable implements Runnable {
        String s;
        int targetNum;
 
        public MyRunnable(String str, int targetNum) {
            this.s = str;
            this.targetNum = targetNum;
        }
 
        @Override
        public void run() {
            synchronized(lock) {
                while(cnt % 4 != targetNum) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                cnt++;
                cnt %= 4;
                System.out.print(s);
                lock.notifyAll();
            }
        }
    }
}