Многопоточность в SWT

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
public class SWTThreads
{
Button b;
Text t;
Display d;
Shell s;
public SWTThreads()
    {
    d = new Display();
    s = new Shell(d);
    t = new Text(s, SWT.RIGHT | SWT.BORDER);
    b = new Button(s, SWT.PUSH);
 
    t.setBounds(100, 100, 300, 300);
    b.setBounds(500,100,200,100);
    s.open();
    
    SWTThreadsEngine engine = new SWTThreadsEngine(this);
    b.addSelectionListener(engine);
    
    while (!s.isDisposed())
        {
        if (!d.readAndDispatch())
            {d.sleep();}
        }
    d.dispose();
    }
public static void main(String[] args)
    {new SWTThreads();}
}

import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
 
public class SWTThreadsEngine extends Thread
implements SelectionListener
{
SWTThreads parent;
SWTThreadsEngine(SWTThreads parent) {this.parent = parent;}
public void widgetSelected(SelectionEvent e) {
    
if (e.getSource().equals(parent.b))
    {parent.d.asyncExec
        (new Runnable()
            {public void run()
                {for (int i=0;i<500000;i++)
                    {System.err.println(i);}
                }
            }
        );
    }
}
public void widgetDefaultSelected(SelectionEvent e){}
}

import java.awt.Toolkit;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.LinkedList;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
 
 
public class HeadThread {
public static final File file = new File ("test.txt");
public static LinkedList<byte []> list = new LinkedList<byte []>();
 
    public static void main(String[] args) throws IOException {
 
        System.out.println(file.getCanonicalPath());
        System.out.println("Стартую Thread1");
        new Thread(new Thread1()).start();
       Thread math = new Thread(new Thread4());
       math.setDaemon(true);
       math.start();
    }
 
}
class Thread1 implements Runnable{
 
    
    @Override
    public void run() {
        try{
            BufferedReader reader = new BufferedReader
                       (new InputStreamReader(System.in));
            
            
        while(true){
            
            System.out.println("Введите что нибуть");
            String temp = "Start Test";
                   temp = reader.readLine();
            
            if(temp.equalsIgnoreCase("end")){
                System.out.println("*! END !*");
                System.exit(0);
//              throw new InterruptedException();
            }
            HeadThread.list.add(temp.getBytes());
            Thread writer = new Thread(new Thread2(HeadThread.list));
            writer.start();
            
            new Thread(new Thread3(writer)).start();
            
            System.out.println("Вы написали это: "+ temp +
                              " в 1 потоке! в " +
                              new Date().getTime());
            
        }
//      }catch(Exception ex ){
//          ex.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 
 
class Thread2 implements Runnable{
public Thread2(String s){
    this.b = s.getBytes();
 
}
public Thread2(byte [] b){
    this.b = b ;
    
}
public Thread2(LinkedList<byte []> list){
    this.list = list;
}
    
    @Override
    public void run() {
        try{
            
        
        System.out.println("Поток 2 Стартовал для шифрования и записи в Файл!");
        
        
        codingFileStream(HeadThread.file,byteMassiveListToArray(list));
 
        System.out.println("Поток 2 Закончил  шифрование и записи в Файл!"
                            +"Поток 3 Может начинать...");
        
        }catch(FileNotFoundException ex){
            ex.printStackTrace();
        }
        catch(IOException ex){
            ex.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
private byte [] b;
 
private LinkedList<byte[]> list;
 
 
public static byte[] codingFileStream(File file,byte[] outBytes) throws FileNotFoundException,IOException{
    DataOutputStream outPut = new DataOutputStream(
              new BufferedOutputStream(
                      new FileOutputStream(file)));
    try{
    for(byte i = 0; i < outBytes.length; i++){
          int temp = outBytes.length + i;
          outBytes[i] = (byte) (outBytes[i]^temp);
      }
      outPut.write(outBytes);
      outPut.flush();
      return outBytes;
      
    }finally{
         outPut.close();
    }
}
public static byte[] byteMassiveListToArray(LinkedList<byte[]> list){
    int length = 0;
    int seek = 0;
    for(byte[] b : list){
        length += b.length; 
    }
    byte [] rez = new byte[length];
    for(int i = 0; i < list.size(); i++){
        for(int j = 0; j < list.get(i).length; j++){
            rez[seek] = list.get(i)[j];
            seek++;
        }
    }
    return rez;
}
 
}
 
class Thread3 implements Runnable{
 
    public Thread3(Thread joined){
        this.joined = joined;
    }
    @Override
    public void run() {
        try{
            joined.join();
            
            JFrame frame = new JFrame();
            frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            frame.setLocation(
                    (int)Toolkit.getDefaultToolkit().getScreenSize().getWidth()/4,
                    (int)Toolkit.getDefaultToolkit().getScreenSize().getHeight()/4
                    );
            frame.setSize(300, 200);
            
            JTextArea area = new JTextArea(3, 4);
            area.setPreferredSize(frame.getPreferredSize());
            area.setEditable(false);
            area.setText(new String(uncodingFileStream(HeadThread.file)));
            
            JScrollPane pane = new JScrollPane(area);
            frame.add(pane);
            
            frame.setVisible(true);
            
            
            
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }
    private Thread joined;
    
    public static byte[] uncodingFileStream(File file) throws FileNotFoundException,IOException{
        
        DataInputStream inPut = new DataInputStream
           (new BufferedInputStream
                  (new FileInputStream(file)));
        
          byte[] inBytes = new byte[(int) file.length()];
          inPut.read(inBytes);
          for(byte i = 0; i < inBytes.length; i++){
              int temp = inBytes.length + i;
              inBytes[i] = (byte) (inBytes[i]^temp);
          }
          inPut.close();
          return inBytes;
        
    }
    
}
class Thread4 implements Runnable{
 
    @Override
    public void run() {
        try{
            
        
        System.out.println("Стартуем Математику");
        
        int d = 959362;
        for(int i =0; i <500; i++){
            d /= 6 * 4 / 2 ^ 5; 
 
            Thread.sleep(5000);
            Date date = new Date();
            date.setMinutes((int)System.currentTimeMillis());
            System.out.println(date.getMinutes());
            System.out.println("Сплю 5 сек ps Thread4");
            
        }
    }catch (InterruptedException ex) {
        ex.printStackTrace();
    }   
        
    }
    
}

import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
 
public class SWTThreadsEngine implements SelectionListener {
    SWTThreads parent;
 
    SWTThreadsEngine(SWTThreads parent) {
        this.parent = parent;
    }
 
    public void widgetSelected(SelectionEvent e) {
        //При нажатии на кнопку создаем и запускаем поток
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                //Запускаем вычисления
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e1) {
                }
 
                //Выводим результат
                parent.d.asyncExec(new Runnable() {
                    @Override
                    public void run() {
                        parent.t.append("q");
                    }
                });
            }
        });
        thread.start();
    }
 
    public void widgetDefaultSelected(SelectionEvent e) {
    }
}