Java多线程实现字符串的反转

要将一个很大数据量的字符串反转，为了提升效率，请采用多线程的方式实现，如输入”123456”，返回”654321"

思路一

          创建一个线程类A，该线程类将传入的字符串进行一个转换。在主线程类中，对要转换的字符串进行分割(分割大小自己定)，根据分割的次数，创建相应的线程A并启动。

import java.util.Scanner;
import java.util.logging.Logger;
class ToInversion extends Thread{
    private String charstring=null;
    public ToInversion(String charstring){
        this.charstring=charstring;
    }
    @Override
    public void run() {
      charstring= new StringBuilder(charstring).reverse().toString();
    }
    public String getCharstring(){
        return this.charstring;
    }
}
public class StringinversionThreadTow {
    public static void main(String[] args) {
        System.out.println("请输入字符串:");
        Scanner scan=new Scanner(System.in);
        String charstring=null;
        StringBuffer getInversionString=new StringBuffer("");
        ToInversion toInversion[]=null;
        while(scan.hasNext())
        {
            charstring=scan.next();
            int k=charstring.length()/3;
            float kf=charstring.length()/3.0f;
            if(kf-k>0){
                k=k+1;
            }
            toInversion=new ToInversion[k];
            for(int i=0,h=0;i<charstring.length();h++){
                if(i+3<charstring.length()){
                    toInversion[h]=new ToInversion(charstring.substring(i,i+3));
                }
                else{
                    toInversion[h]=new ToInversion(charstring.substring(i));
                }
                toInversion[h].start();
                i=i+3;
            }
            for(int i=toInversion.length-1;i>=0;i--){
                getInversionString.append(toInversion[i].getCharstring());
            }
            System.out.println("反转后的字符串为:");
            System.out.println(getInversionString.toString());
        }
    }
}

思路二

          模仿消费者和生产者问题实现，将要转化的字符串作为公共资源，一个线程类读取字符串，一个线程类转换该字符串。

代码实现

import java.util.Scanner;
import java.util.Stack;
import java.util.Vector;

//常见一个字符串类作为临界资源
class Charclass{
    private String resources;
    private boolean bFull=false;
    public synchronized  void getResources() {
        if(!bFull){
            try{
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        bFull=false;
        System.out.println("反后的字");
        notify();
    }
    public synchronized void setResources(String resources) {
        if(bFull){
            try{
                wait();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.resources = resources;
        Stack sch=new Stack();
        for(int i=0;i<resources.length();i++){
            sch.push(resources.toCharArray()[i]);
        }
        bFull=true;
        System.out.print("反转后的字符串为：");
        int j=sch.size();
        for(int i=0;i<j;i++){
            System.out.print(sch.pop());
        }

        notify();
    }
}
//产生字符串
class ProducerChar implements Runnable{
    Charclass ch=null;
    public ProducerChar(Charclass ch){
        this.ch=ch;
    }
    @Override
    public void run() {
        System.out.println("请输入字符串:");
        Scanner scan=new Scanner(System.in);
        while(scan.hasNext())
        {
            ch.setResources(scan.next());
        }
    }
}
//输入字符串到栈中
class ConsunmerChar implements Runnable{
    Charclass ch=null;
    public ConsunmerChar(Charclass ch){
        this.ch=ch;
    }
    @Override
    public void run() {

    }
}
public class StringInversionThread {
    public static void main(String[] args) {
        Charclass ch=new Charclass();
        new Thread(new ProducerChar(ch)).start();
        new Thread(new ConsunmerChar(ch)).start();
    }
}

运行结果