线程的部分代码

把线程内容的部分代码摘录如下

package Thread;
//本例题展示了单线程的情况,输出结果只输出son.run();的执行情况
//sonmainson
//sonmainson
//sonmainson
//sonmainson
//

public class TestA ...{
    public static void main(String[] args)
    ...{
        MyThread son=new MyThread();
        son.run();
        while(true)
        ...{
            System.out.println("main"+Thread.currentThread().getName()+"main");
        }
    }
}
class MyThread 
...{
    
    void run()
    ...{
        while(true)
        ...{
            System.out.println("son"+Thread.currentThread().getName()+"son");
        }
    }

}

 

package Thread;
//本例实现了多线程,通过继承Thread实现
//mainmainmain
//mainmainmain
//mainmainmain
//mainmainmain
//mainmainmain
//mainmainmain
//mainmainmain
//sonThread-0son
//sonThread-0son
//sonThread-0son
//看到主线程和子线程交替执行

public class TestB ...{
    public static void main(String[] args)
    ...{
        //MyThread2 son=new MyThread2();
        //son.start();
        new MyThread2().start();//此处应用了匿名对象,和上述注释一样
        while(true)
        ...{
            System.out.println("main"+Thread.currentThread().getName()+"main");
        }
    }
}
class MyThread2 extends Thread  
...{
    
    public void run()
    ...{
        while(true)
        ...{
            System.out.println("son"+Thread.currentThread().getName()+"son");
        }
    }

}

package Thread;


public class TestC ...{
    public static void main(String[] args)
    ...{
        //MyThread2 son=new MyThread2();
        //son.start();
        new MyThread3().start();//此处应用了匿名对象,和上述注释一样
        while(true)
        ...{
            System.out.println("main"+Thread.currentThread().getName()+"main");
        }
    }
}
class MyThread3 extends Thread  
...{
    
    public void run()
    ...{
        while(true)
        ...{
            System.out.println("son"+Thread.currentThread().getName()+"son");
        }
    }

}

package Thread;
//本例展示了Join的应用
//tt.join()后,整个程序又变成了一个线程,因为把它加入到了主线程,所以当完成100以后,持续输出son
//tt.join(1000)后,程序持续运行son10秒,然后交替输出main和son
public class TestJoin ...{
    public static void main(String[] args)
    ...{
        Thread tt=new MyThreadJoin();
        tt.start();
        int count=0;
        while(true)
        ...{    if(count++==1000)
                //try{tt.join();}catch(Exception e){}
                try...{tt.join(10000);}catch(Exception e)...{} //此处显示了加入10秒后,将交替输出main和son
            System.out.println("main"+Thread.currentThread().getName()+"main");
        }
    }
}
class MyThreadJoin extends Thread
...{
    public void run()
    ...{
        while(true)
        ...{    
            System.out.println("son");
        }
    }
}

package Thread;
//该例展示了后台线程的运行情况,当主程序结束后,后台线程会及时终止
//如果不设置daemon,则线程会一直运行,虽然主程序main()已经结束
public class TestZ ...{
    public static  void main(String[] args)
    ...{
        Thread dog=new th();
        dog.setDaemon(true);//dog设置为了后台线程
        dog.start();
    }
}

class th extends Thread
...{
    public void run()
    ...{
        while(true)
        ...{
                System.out.println("ald");
        }
    
    }
    }

package Thread;

public class ErrorDemo ...{
    
    public static void main(String[] args)
    ...{
        RRr rr=new RRr();
        new Thread(rr).start();
        new Thread(rr).start();
        new Thread(rr).start();
        new Thread(rr).start();
    }

}






class RRr implements Runnable
...{
    int count=100;
    public void run()
    ...{
        
        while(true)
        ...{
            
        if(count>0)
        ...{
            try...{Thread.sleep(10);}catch(Exception e)...{}
            System.out.println(Thread.currentThread().getName()+"si saling"+count--);
        }
        }
    }
}

package Thread;

public class RunnableDemo ...{
    public static void main(String[] args)
    ...{
        new Thread(new R()).start();//注意此处的应用方式Thread的构造函数以R为参数,故调用R.run()
        new Thread(new R()).start();
        new Thread(new R()).start();
        new Thread(new R()).start();
        while(true)
        ...{
            System.out.println("main");
        }
    }
}
class R implements Runnable
...{
    int tickets=100;
    public void run()
    ...{
        while(true)
        ...{
            System.out.println(Thread.currentThread().getName()+(tickets--));
        }
    }
}

package Thread;

public class SaleTicketsWithRunnable ...{
    public static void main(String[] args)
    ...{
        RR rr=new RR();
        new Thread(rr).start();
        new Thread(rr).start();
        new Thread(rr).start();
        new Thread(rr).start();
    }
}
class RR implements Runnable
...{
    int count=100;
    public void run()
    ...{
        
        while(true)
        ...{
        if(count>0)
        System.out.println(Thread.currentThread().getName()+"si saling"+count--);
        }
    }
}

package Thread;

public class SaleTicketsWithThread ...{
    public static void main(String[] args)
    ...{
        new T().start();
        new T().start();
        new T().start();
        new T().start();
        /**//*Thread tt=new T();
        tt.start();        
        tt.start();        
        tt.start();*/
        
        
    }

}




class T extends Thread//implements Runnable
...{
    int tickets=100;
    public void run()
    ...{
        while(true)
        ...{
            if(tickets>0)
            System.out.println(Thread.currentThread().getName()+"is selling the tickets:"+(tickets--));
        }
    }
}

package Thread;

public class SynchronizedDemo ...{
    public static void main(String[] args)
    ...{
        RRrr rr=new RRrr();
        new Thread(rr).start();
        new Thread(rr).start();
        new Thread(rr).start();
        new Thread(rr).start();
    }
}
class RRrr implements Runnable
...{
    int count=100;
    String str=new String("");//如果将str放到run()方法中,线程将不再同步
    //原因是因为每个线程都有了自己的str对象,每个使用的是各自的str对象
    public void run()
    ...{
        
        while(true)
        ...{
        //synchronized(this)  此处用this也可以
        synchronized(str)
        ...{    
            if(count>0)
            ...{
                try...{Thread.sleep(10);}catch(Exception e)...{}
                System.out.println(Thread.currentThread().getName()+"si saling"+count--);
            }
        }
        }
    }
}

package Thread;

public class SynchronizedInFunction ...{
    public static void main(String[] args)
    ...{
        RRrrr rr=new RRrrr();
        new Thread(rr).start();
        new Thread(rr).start();
        new Thread(rr).start();
        new Thread(rr).start();
    }
}





    

class RRrrr implements Runnable
...{
    int count=100;
    public void run()
    ...{
        
        while(true)
        ...{
          sale();
        
        }
    }
    public synchronized void sale()// synchronized 此处表示同步的是整个函数
    ...{
            
            if(count>0)
            ...{
                try...{Thread.sleep(10);}catch(Exception e)...{}
                System.out.println(Thread.currentThread().getName()+"si saling"+count--);
            }
    
    }
}

package Thread;

class Producer implements Runnable
...{
    Q q=null;
    public Producer(Q q)
...{
    this.q=q;
}
    public void run()
...{
    int i=0;
    while(true)
...{
    if(i==0)
    ...{
q.name="nan";
        q.sex="男";
    }
    else
    ...{
q.name="nv";
        q.sex="女";
    }
    i=(i+1)%2;
}
}
}
class Q
...{
    String name="nv";
    String sex="女";
}
class Consumer implements Runnable
...{
    Q q=null;
    public Consumer(Q q)
    ...{
        this.q=q;
    }
    public void run()
...{
    while(true)
...{
    System.out.println("take it:"+q.name + "---->" + q.sex);
}
}
} 
public class ThreadCommunation
...{
    public static void main(String [] args)
    ...{
        Q q=new Q();
        new Thread(new Producer(q)).start();
        new Thread(new Consumer(q)).start();
    }
}

package mod13;

public class Consumer implements Runnable ...{
    private SyncStack theStack;
    private int num;
    private static int counter=1;
    public Consumer(SyncStack s)
    ...{
        theStack=s;
        num=counter++;
    }
    public void run()
    ...{
        char c;
        for(int i=0;i<200;i++)
        ...{
            c=theStack.pop();
            System.out.println("Consumer"+num+":"+c);
            try
            ...{
                Thread.sleep((int)(Math.random()*300));
                
            }catch(InterruptedException e)
            ...{
                
            }
        }
    }
}



package mod13;

public class Producer implements Runnable...{
    private SyncStack theStack;
    private int num;
    private static int counter=1;
    public Producer(SyncStack s)
    ...{
        theStack=s;
        num=counter++;
    }
    public void run()
    ...{
        char c;
        for(int i=0;i<200;i++)
        ...{
            c=(char)(Math.random()*26+'A');
            theStack.push(c);
            System.out.println("Producer"+num+":"+c);
            try
            ...{
                Thread.sleep((int)(Math.random()*300));
            }
            catch(InterruptedException e)
            ...{
                
            }
        }
    }
}


package mod13;
import java.util.*;
public class SyncStack ...{
    private List <Character>  buffer=new ArrayList <Character>(400);
    //public Synchronized char pop()
    public synchronized char pop()
    
    ...{
        char c;
        while(buffer.size()==0)
        ...{
            try...{
                this.wait();
            }catch(InterruptedException e)
            ...{
                
            }
        }
        c=buffer.remove(buffer.size()-1);
        return c;
        
    }
    public synchronized void push(char c)
    ...{
        this.notify();
        buffer.add(c);
    }
}



package mod13;

public class SyncTest ...{
    public static void main(String[] args)
    ...{
        SyncStack stack=new SyncStack();
        
        Producer p1=new Producer(stack);
        Thread prodT1=new Thread(p1);
        prodT1.start();
        
        
        Producer p2=new Producer(stack);
        Thread prodT2=new Thread(p2);
        prodT2.start();
        
        Consumer c1=new Consumer(stack);
        Thread consT1=new Thread(c1);
        consT1.start();
        
        
        
        Consumer c2=new Consumer(stack);
        Thread consT2=new Thread(c2);
        consT2.start();
        
        
        /**//*Consumer c1=new Consumer(stack);
        Thread consT1=new Thread(c1);
        consT1.start();
        
        
        */
        
    }
}