第六周 技术博客

 

 

非常不好意思上周的技术博客真的是排版各种乱，我今天才知道有插入代码的方式

 

我在下面试试直接插入代码

 

其实看完之后可以发现最后一行没有输出，这就是守护线程还没有执行完就结束了，我在找解决方案，或许可以在另一个线程里用interrupt结束而不是用守护线程的方式

/*
题目：输入十个数，如果输入的和之前输入的一样就不输入
        （我用了多线程锻炼一下自己的编程能力）
        一个线程输入，另一个线程直接运算并且输出，之前的线程就可以直接再输入，不用等待输出结束

*/
import java.util.ArrayList;
import java.util.Scanner;
import java.util.concurrent.locks.*;

class Sort
{
    Lock lock = new ReentrantLock();
    Condition con_in = lock.newCondition();
    Condition con_sr = lock.newCondition();
    
    private boolean flag=false;            //判断标记

    ArrayList<Integer> list;

    public Sort(ArrayList<Integer> list)        
    {
        this.list= list;
    }

    Scanner input = new Scanner(System.in);

    public void sortArray() throws InterruptedException  //线程t1执行的对数组列表进行判断
    {
        lock.lock();
        try
        {
            while(!flag)
                con_sr.await();

            for (int i=0;i<list.size()-1 ;i++ )
            {
                for (int j=i+1;j<list.size() ;j++ )
                {
                    if(list.get(i)==list.get(j))
                        list.remove(j);
                }
            }
            System.out.print("current array is: ..");
            for(int k = 0;k<list.size();k++)
                System.out.print(list.get(k)+" ");
            System.out.println();

            flag=false;
            con_in.signal();
        }
        finally
        {
            lock.unlock();
        }



        
    
        
    }

    public void inputArray() throws InterruptedException    //输入值
        
    {    
        lock.lock();
        try
        {
            while(flag)
                con_in.await();
            Integer temp = input.nextInt();
            list.add(temp);
            flag=true;
            con_sr.signal();
        }
        finally
        {
            lock.unlock();
        }
        
    }
}

class In implements Runnable        //线程2的run方法封装
{
    Sort s;
    In(Sort s)
    {
        this.s= s;
    }

    public void run()
    {
        for (int i = 0; i <10 ;i++ )
        {
            try
            {
                s.inputArray();
            }
            catch (InterruptedException e)
            {
            }
            
        }

    }
}

class Sr implements Runnable        //线程1的run方法封装
{
    Sort s;
    Sr(Sort s)
    {
        this.s=s;
    }
    public void run()
    {
        while (true)
            try
            {
                s.sortArray();
            }
            catch (InterruptedException e)
            {
            }
    }
}





class SortDemo
{


    @SuppressWarnings("unchecked")public static void main(String[] args) 
    {
        

        ArrayList<Integer> list = new ArrayList();
        Sort s = new Sort(list);

        Thread t1= new Thread(new Sr(s));
        Thread t2= new Thread(new In(s));
        t1.setDaemon(true);                        //输出线程设置成守护线程

         t1.start();
         t2.start();

    }
}