Please guide me to do encryption with thread; RejectedExecutionException

[Sara Brown]

i found this code in serial in the internet. but i want to modified so it can used thread.

public key(ExecutorService exe, List<Future> futures, String mode, KeyAgreement bobKeyAgree, KeyAgreement aliceKeyAgree, boolean quest){
		this.exe = exe;
		this.futures = futures;
		this.mode = mode;
		this.bobKeyAgree = bobKeyAgree;
		this.aliceKeyAgree = aliceKeyAgree;
		this.quest = quest;
		System.out.println("future: " + futures);
		System.out.println("quest: " + quest);
	}			
	
	@Override
	public void run(){
		
        try {
        	if(quest == true){
        	SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");
            SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");
                        
            // Bob encrypts, using DES in ECB mode        
            Cipher bobCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);
            
            byte[] cleartext = "a".getBytes();
            System.out.println("cleartext length: " + cleartext.length);
            System.out.println("cleartext.......");
            for(int a = 0; a < cleartext.length; a++){        	
            	System.out.print(cleartext[a] + " ");        	
            }
            System.out.println();
            byte[] ciphertext = bobCipher.doFinal(cleartext);
                                   
            
            // Alice decrypts, using DES in ECB mode       
            Cipher aliceCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey);
            byte[] recovered = aliceCipher.doFinal(ciphertext);
                
            if (!java.util.Arrays.equals(cleartext, recovered))
                throw new Exception("DES in CBC mode recovered text is different from cleartext");
            System.out.println("DES in ECB mode recovered text is same as cleartext");    

            
            
            
            // Bob encrypts, using DES in CBC mode     
            bobCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
            bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);

            cleartext = "a".getBytes();
            System.out.println("Cleartext2: +++++");
            for(int a = 0; a < cleartext.length; a++){        	
            	System.out.print(cleartext[a] + " ");        	
            }
            ciphertext = bobCipher.doFinal(cleartext);
            // Retrieve the parameter that was used, and transfer it to Alice in encoded format
            byte[] encodedParams = bobCipher.getParameters().getEncoded();
            
            
            
            // Alice decrypts, using DES in CBC mode
            // Instantiate AlgorithmParameters object from parameter encoding obtained from Bob
            AlgorithmParameters params = AlgorithmParameters.getInstance("DES");
            params.init(encodedParams);
            aliceCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
            aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey, params);
            recovered = aliceCipher.doFinal(ciphertext);                            
            
            if (!java.util.Arrays.equals(cleartext, recovered))
                throw new Exception("DES in CBC mode recovered text is " +
                  "different from cleartext");
            System.out.println("DES in CBC mode recovered text is " +
                "same as cleartext");  
        	}
        } catch (Exception e) {			
			e.printStackTrace();
		}        		
        	
        	
        	
        	
        	
        	
        	try{
        	//futures.add(exe.submit(new key(exe, futures, mode)));
        	
        	DHParameterSpec dhSkipParamSpec;
            
            // use some pre-generated, default DH parameters
            System.out.println("Using SKIP Diffie-Hellman parameters");
            
            // Alice creates her own DH key pair, using the DH parameters from above     
            System.out.println("ALICE: Generate DH keypair ...");
            KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
            //aliceKpairGen.initialize(dhSkipParamSpec);
            KeyPair aliceKpair = aliceKpairGen.generateKeyPair();

            // Alice creates and initializes her DH KeyAgreement object
            System.out.println("ALICE: Initialization ...");
            KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
            aliceKeyAgree.init(aliceKpair.getPrivate());

            // Alice encodes her public key, and sends it over to Bob.
            byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();

            /*
             * Let's turn over to Bob. Bob has received Alice's public key in encoded format.
             * He instantiates a DH public key from the encoded key material.
             */
            KeyFactory bobKeyFac = KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(alicePubKeyEnc);
            System.out.println("x509KeySpec: " + x509KeySpec);
            PublicKey alicePubKey = bobKeyFac.generatePublic(x509KeySpec);

            /*
             * Bob gets the DH parameters associated with Alice's public key. 
             * He must use the same parameters when he generates his own key pair.
             */
            DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();

            // Bob creates his own DH key pair
            System.out.println("BOB: Generate DH keypair ...");
            KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
            bobKpairGen.initialize(dhParamSpec);
            KeyPair bobKpair = bobKpairGen.generateKeyPair();

            // Bob creates and initializes his DH KeyAgreement object
            System.out.println("BOB: Initialization ...");
            KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
            bobKeyAgree.init(bobKpair.getPrivate());

            // Bob encodes his public key, and sends it over to Alice.
            byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

            /*
             * Alice uses Bob's public key for the first (and only) phase of her version of the DH protocol.
             * Before she can do so, she has to instanticate a DH public key from Bob's encoded key material.
             */
            KeyFactory aliceKeyFac = KeyFactory.getInstance("DH");
            x509KeySpec = new X509EncodedKeySpec(bobPubKeyEnc);
            PublicKey bobPubKey = aliceKeyFac.generatePublic(x509KeySpec);
            
            //Alice use public key
            System.out.println();
            System.out.println("ALICE: Execute PHASE1 ...");
            aliceKeyAgree.doPhase(bobPubKey, true);

            /*
             * Bob uses Alice's public key for the first (and only) phase of his version of the DH protocol.
             */
            System.out.println("BOB: Execute PHASE1 ...");
            bobKeyAgree.doPhase(alicePubKey, true);
                
            /*
             * At this stage, both Alice and Bob have completed the DH key agreement protocol.
             * Both generate the (same) shared secret.
             */
            byte[] aliceSharedSecret = aliceKeyAgree.generateSecret();
            System.out.println("aliceSharedSecret: " + aliceSharedSecret);
            int aliceLen = aliceSharedSecret.length;
            
            System.out.println();
            System.out.println("aliceLength: " + aliceLen);

            byte[] bobSharedSecret = new byte[aliceLen];       
            
            int bobLen;
            
            // provide output buffer of required size
            bobLen = bobKeyAgree.generateSecret(bobSharedSecret, 0);
            System.out.println("bobLen: " + bobLen);
            System.out.println();
            
            System.out.println("Alice secret: " + toHexString(aliceSharedSecret));
            System.out.println("Bob secret: " + toHexString(bobSharedSecret));

            if (!java.util.Arrays.equals(aliceSharedSecret, bobSharedSecret))
                throw new Exception("Shared secrets differ");
            System.out.println("Shared secrets are the same");
            
            
            
            
            System.out.println("Return shared secret as SecretKey object ...");
            // Bob
            // Note: The call to bobKeyAgree.generateSecret above reset the key
            // agreement object, so we call doPhase again prior to another generateSecret call
            // Alice
            // Note: The call to aliceKeyAgree.generateSecret above reset the key
            // agreement object, so we call doPhase again prior to another generateSecret call
            bobKeyAgree.doPhase(alicePubKey, true);//doPhase is written at the end
            aliceKeyAgree.doPhase(bobPubKey, true);                                   
            
            quest = true;
            
            futures.add(exe.submit(new key(exe, futures, mode, bobKeyAgree, aliceKeyAgree, quest)));  
            
            
            System.out.println("End time: " + System.currentTimeMillis());			
		} catch (Exception e) {			
			e.printStackTrace();
		}        		
     
		}		

public class EncryptThread {
	public static void main(String[] args){				
	    //System.out.println("Start time: " + System.currentTimeMillis());
		
		final ExecutorService exe = Executors.newFixedThreadPool(2);
        List<Future> futures = new Vector<Future>();
		
		try{
		String mode = "abc";
			    
	    System.out.println("try");
	   	System.out.println("modeTRY: " + mode);	       
       	//Java cryptogrpahy extension
       	EncryptThread keyAgree = new EncryptThread();                                              
        //keyAgree.run(mode);    	                
        
        KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
        KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
        
        boolean quest = false;
        
        key rootTask = new key(exe, futures, mode, bobKeyAgree, aliceKeyAgree, quest);
        futures.add(exe.submit(rootTask));
        //System.out.println("modeMain: " + mode);
                        
		}catch(Exception e){}
		exe.shutdown();
	    
	    System.out.println("end");

	}
}

it says RejectedExecutionException. please guide me to modified this code. I have read some article and in my understanding it seems to be correct unfortunately its not. please..
lets say i still want to use executorService. Thank you.