华为OJ训练之0030-170110-多线程

题目

===============================================

问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由线程函数1的参数指定。[注：C语言选手可使用WINDOWS SDK库函数]

接口说明：

void init(); //初始化函数

void Release(); //资源释放函数

unsignedint__stdcall ThreadFun1(PVOID pM) ; //线程函数1，传入一个int类型的指针[取值范围：1 – 250，测试用例保证]，用于初始化输出A次数，资源需要线程释放

unsignedint__stdcall ThreadFun2(PVOID pM) ;//线程函数2，无参数传入

unsignedint__stdcall ThreadFun3(PVOID pM) ;//线程函数3，无参数传入

Unsigned int __stdcall ThreadFunc4(PVOID pM);//线程函数4，无参数传入

char g_write[1032]; //线程1,2,3,4按顺序向该数组赋值。不用考虑数组是否越界，测试用例保证

知识点 字符串,循环,链表,队列,栈,查找,搜索,排序,树,图,数组,函数,指针,枚举,位运算,结构体,联合体,文件操作,递归

运行时间限制 10M

内存限制 128

输入

输入一个int整数

输出

输出多个ABCD

样例输入 10

样例输出 ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD

100

在多线程开发中，经常会出现一种情况，我们希望读写分离。就是对于读取这个动作来说，可以同时有多个线程同

时去读取这个资源，但是对于写这个动作来说，只能同时有一个线程来操作，而且同时，当有一个写线程在操作这个资

源的时候，其他的读线程是不能来操作这个资源的，这样就极大的发挥了多线程的特点，能很好的将多线程的能力发挥

出来。

在Java中，ReadWriteLock这个接口就为我们实现了这个需求，通过他的实现类ReentrantReadWriteLock我们可

以很简单的来实现刚才的效果，下面我们使用一个例子来说明这个类的用法。

[java] view plain copy print?

package com.bird.concursey.charpet3;

import java.util.concurrent.locks.ReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class PricesInfo {

private double price1;

private double price2;

private ReadWriteLock lock;

public PricesInfo() {
price1 = 1.0;
price2 = 2.0;
lock = new ReentrantReadWriteLock();
}

public double getPrice1() {
//读取资源锁定
lock.readLock().lock();
double value = price1;
lock.readLock().unlock();
return value;
}

public double getPrice2() {
lock.readLock().lock();
double value = price2;
lock.readLock().unlock();
return value;
}

public void setPrices(double price1, double price2) {
lock.writeLock().lock();
this.price1 = price1;
this.price2 = price2;
lock.writeLock().unlock();
}

}

===============================================

package package02;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

import javax.swing.plaf.SliderUI;

//问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由线程函数1的参数指定。[注：C语言选手可使用WINDOWS SDK库函数]
//接口说明：
//void init();  //初始化函数
//void Release(); //资源释放函数
//unsignedint__stdcall ThreadFun1(PVOID pM)  ; //线程函数1，传入一个int类型的指针[取值范围：1 – 250，测试用例保证]，用于初始化输出A次数，资源需要线程释放
//unsignedint__stdcall ThreadFun2(PVOID pM)  ;//线程函数2，无参数传入
//unsignedint__stdcall ThreadFun3(PVOID pM)  ;//线程函数3，无参数传入
//Unsigned int __stdcall ThreadFunc4(PVOID pM);//线程函数4，无参数传入
//char  g_write[1032]; //线程1,2,3,4按顺序向该数组赋值。不用考虑数组是否越界，测试用例保证
//知识点   字符串,循环,链表,队列,栈,查找,搜索,排序,树,图,数组,函数,指针,枚举,位运算,结构体,联合体,文件操作,递归
//运行时间限制    10M
//内存限制  128
//输入
//输入一个int整数
//输出
//输出多个ABCD
//样例输入  10
//样例输出  ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD

public class oj030 {

private ReadWriteLock lock=new ReentrantReadWriteLock();
private int n=0;

public oj030(int n) {
this.n=n;
}

private List<Character> list=new ArrayList<Character>();

private Thread threadA=new Thread(new Runnable() {

@Override
public void run() {

int na=0;
while(na!=n)
{
lock.writeLock().lock();
if(list.size()%4==0)
{
list.add('A');
na++;
}
lock.writeLock().unlock();

}
}
});
private Thread threadB=new Thread(new Runnable() {

@Override
public void run() {
int nb=0;
while(nb!=n)
{
lock.writeLock().lock();
if(list.size()%4==1)
{
list.add('B');
nb++;
}
lock.writeLock().unlock();

}
}
});
private Thread threadC=new Thread(new Runnable() {

@Override
public void run() {
int nc=0;
while(nc!=n)
{
lock.writeLock().lock();
if(list.size()%4==2)
{
list.add('C');
nc++;
}
lock.writeLock().unlock();

}
}
});

private Thread threadD=new Thread(new Runnable() {

@Override
public void run() {
int nd=0;
while(nd!=n)
{
lock.writeLock().lock();
if(list.size()%4==3)
{
list.add('D');
nd++;
}
lock.writeLock().unlock();

}
}
});

public void startThread()
{

threadA.start();
threadB.start();
threadC.start();
threadD.start();

}

public void display()
{

try {
threadA.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
lock.readLock().lock();
if(list!=null)
{
for(Character c:list)
{
System.out.print(c);
}
}
lock.readLock().unlock();
}

public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();

oj030 oj=new oj030(n);
oj.startThread();
oj.display();

}

}