java多线程

来源:互联网 发布:手机号码短信接收软件 编辑:程序博客网 时间:2024/06/16 01:03

1、多线程有几种实现方法?同步有几种实现方法?

多线程有两种实现方法,分别是继承Thread类与实现Runnable接口

同步的实现方面有两种,分别是synchronized,waitnotify

wait():使一个线程处于等待状态,并且释放所持有的对象的lock

sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉InterruptedException异常。

notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。

Allnotity():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争。 

 

2、启动一个线程是用run()还是start()? .

启动一个线程是调用start()方法,使线程就绪状态,以后可以被调度为运行状态,一个线程必须关联一些具体的执行代码,run()方法是该线程所关联的执行代码。

 

3、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法?

分几种情况:

    1.其他方法前是否加了synchronized关键字,如果没加,则能。

    2.如果这个方法内部调用了wait,则可以进入其他synchronized方法。

    3.如果其他个方法都加了synchronized关键字,并且内部没有调用wait,则不能。

    4.如果其他方法是static,它用的同步锁是当前类的字节码,与非静态的方法不能同步,因为非静态的方法用的是this

 

4、线程的基本概念、线程的基本状态以及状态之间的关系

 

一个程序中可以有多条执行线索同时执行,一个线程就是程序中的一条执行线索,每个线程上都关联有要执行的代码,即可以有多段程序代码同时运行,每个程序至少都有一个线程,即main方法执行的那个线程。如果只是一个cpu,它怎么能够同时执行多段程序呢?这是从宏观上来看的,cpu一会执行a线索,一会执行b线索,切换时间很快,给人的感觉是a,b在同时执行,好比大家在同一个办公室上网,只有一条链接到外部网线,其实,这条网线一会为a传数据,一会为b传数据,由于切换时间很短暂,所以,大家感觉都在同时上网。

 

 状态:就绪,运行,synchronize阻塞,waitsleep挂起,结束。wait必须在synchronized内部调用。

 调用线程的start方法后线程进入就绪状态,线程调度系统将就绪状态的线程转为运行状态,遇到synchronized语句时,由运行状态转为阻塞,当synchronized获得锁后,由阻塞转为运行,在这种情况可以调用wait方法转为挂起状态,当线程关联的代码执行完后,线程变为结束状态。

 

5、简述synchronizedjava.util.concurrent.locks.Lock的异同?

主要相同点:Lock能完成synchronized所实现的所有功能

主要不同点:Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁,而Lock一定要求程序员手工释放,并且必须在finally从句中释放。Lock还有更强大的功能,例如,它的tryLock方法可以非阻塞方式去拿锁。

举例说明(对下面的题用lock进行了改写): 

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock; 

publicclass ThreadTest { 

    /**

     * @param args

     */

    

    private int j;

    private Lock lock =new ReentrantLock();

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       ThreadTest tt = new ThreadTest();

       for(int i=0;i<2;i++) {

           new Thread(tt.new Adder()).start();

           new Thread(tt.new Subtractor()).start();

       }

    } 

    private class Subtractorimplements Runnable    { 

       @Override

       public void run() {

           // TODO Auto-generated method stub

           while(true)  {

              /*synchronized (ThreadTest.this) {       

                  System.out.println("j--=" + j--);

                  //这里抛异常了,锁能释放吗?

              }*/

              lock.lock();

              try {

                  System.out.println("j--=" + j--);

              }finally {

                  lock.unlock();

              }

           }

       }       

    }    

    private class Adderimplements Runnable 

       @Override

       public void run() {

           // TODO Auto-generated method stub

           while(true{

              /*synchronized (ThreadTest.this) {

              System.out.println("j++=" + j++); 

              }*/

              lock.lock();

               try

              {

                  System.out.println("j++=" + j++);

              }finally

              {

                  lock.unlock();

              }            

           }         

       }      

    }

}

6、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。********

以下程序使用内部类实现线程,对j增减的时候没有考虑顺序问题。

public class ThreadTest1

{

private int j;

public static void main(String args[]){

  ThreadTest1 tt=new ThreadTest1();

  Inc inc=tt.new Inc();

  Dec dec=tt.new Dec();

  for(int i=0;i<2;i++){

      Thread t=new Thread(inc);

      t.start();

          t=new Thread(dec);

      t.start();

      }

  }

private synchronized void inc(){

  j++;

  System.out.println(Thread.currentThread().getName()+"-inc:"+j);

  }

private synchronized void dec(){

  j--;

  System.out.println(Thread.currentThread().getName()+"-dec:"+j);

  }

class Inc implements Runnable{

  public void run(){

      for(int i=0;i<100;i++){

      inc();

      }

  }

}

class Dec implements Runnable{

  public void run(){

      for(int i=0;i<100;i++){

      dec();

      }

  }

}

}

 

----------随手再写的一个-------------

class A

{

JManger j =new JManager();

main()

{

  new A().call();

}

 

void call

{

  for(int i=0;i<2;i++)

  {

       new Thread(

              new Runnable(){ public void run(){while(true){j.accumulate()}}}

       ).start();

       new Thread(new Runnable(){ public void run(){while(true){j.sub()}}}).start();

  }

}

}

 

class JManager

{

  private j = 0;

  

  public synchronized void subtract()

  {

       j--

  }

  

  public synchronized void accumulate()  {

       j++;

  }  

} 

7、子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次,请写出程序。

 

最终的程序代码如下:

publicclass ThreadTest { 

    /**

     * @param args

     */

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       new ThreadTest().init();

 

    }

 

    public void init()

    {

       final Business business =new Business();

       new Thread(

              new Runnable()

              {

 

                  public void run() {

                     for(int i=0;i<50;i++)

                     {

                         business.SubThread(i);

                     }                   

                  }

                  

              }

       

       ).start();

       

       for(int i=0;i<50;i++)

       {

           business.MainThread(i);

       }     

    }

    

    private class Business

    {

       booleanbShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯

       public synchronized void MainThread(int i)

       {

           if(bShouldSub)

              try {

                  this.wait();

              catch (InterruptedException e) {

                  // TODO Auto-generated catch block

                  e.printStackTrace();

              }     

              

           for(int j=0;j<5;j++)

           {

              System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);

           }

           bShouldSub =true;

           this.notify();

       

       }

       

       

       public synchronized void SubThread(int i)

       {

           if(!bShouldSub)

              try {

                  this.wait();

              catch (InterruptedException e) {

                  // TODO Auto-generated catch block

                  e.printStackTrace();

              }  

              

           for(int j=0;j<10;j++)

           {

              System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);

           }

           bShouldSub =false;            

           this.notify();          

       }

    }

}

 

备注:不可能一上来就写出上面的完整代码,最初写出来的代码如下,问题在于两个线程的代码要参照同一个变量,即这两个线程的代码要共享数据,所以,把这两个线程的执行代码搬到同一个类中去: 

publicclass ThreadTest {    

    private static booleanbShouldMain = false;    

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       /*new Thread(){

       public void run() {

           for(int i=0;i<50;i++)  {

              for(int j=0;j<10;j++)  {

                  System.out.println("i=" + i + ",j=" + j);

              }

           }            

       }

       

    }.start();*/           

       

       //final String str = new String("");

 

       new Thread(

              new Runnable()

              {

                  public void run()

                  {

                     for(int i=0;i<50;i++)

                     {

                         synchronized (ThreadTest.class) {

                            if(bShouldMain)

                            {

                                 try {

                                    ThreadTest.class.wait();}

                                 catch (InterruptedException e) {

                                    e.printStackTrace();

                                 }

                            }

                            for(int j=0;j<10;j++)

                            {

                                 System.out.println(

                                      Thread.currentThread().getName() +

                                      "i=" + i + ",j=" + j);

                            }

                             bShouldMain = true;

                            ThreadTest.class.notify();

                         }                       

                     }                   

                  }

              }

       ).start();

       

       for(int i=0;i<50;i++)

       {

           synchronized (ThreadTest.class) {

              if(!bShouldMain)

              {

                  try {

                     ThreadTest.class.wait();}

                  catch (InterruptedException e) {

                     e.printStackTrace();

                  }

              }            

              for(int j=0;j<5;j++)

              {

                  System.out.println(

                         Thread.currentThread().getName() +                  

                         "i=" + i + ",j=" + j);

              }

              bShouldMain =false;

              ThreadTest.class.notify();            

           }         

       }

    }

 

}

下面使用jdk5中的并发库来实现的:

import java.util.concurrent.Executors;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import java.util.concurrent.locks.Condition;

 

public class ThreadTest

{

      private static Lock lock = new ReentrantLock();

      private static Condition subThreadCondition = lock.newCondition();

      private static boolean bBhouldSubThread = false;

      public static void main(String [] args)

      {

             ExecutorService threadPool = Executors.newFixedThreadPool(3);

             threadPool.execute(new Runnable(){

                    public void run()

                    {

                           for(int i=0;i<50;i++)

                           {

                                  lock.lock();                                

                                  try

                                  {                                

                                         if(!bBhouldSubThread)

                                                subThreadCondition.await();

                                         for(int j=0;j<10;j++)

                                         {

                                                System.out.println(Thread.currentThread().getName() + ",j=" + j);

                                         }

                                         bBhouldSubThread = false;

                                         subThreadCondition.signal();

                                  }catch(Exception e)

                                  {                                       

                                  }

                                  finally

                                  {

                                         lock.unlock();

                                  }

                           }                  

                    }

                    

             });

             threadPool.shutdown();

             for(int i=0;i<50;i++)

             {

                           lock.lock();                                

                           try

                           {    

                                  if(bBhouldSubThread)

                                                subThreadCondition.await();                                                  

                                  for(int j=0;j<10;j++)

                                  {

                                         System.out.println(Thread.currentThread().getName() + ",j=" + j);

                                  }

                                  bBhouldSubThread = true;

                                  subThreadCondition.signal();                            

                           }catch(Exception e)

                           {                                       

                           }

                           finally

                           {

                                  lock.unlock();

                           }                                

             }

      }

}


0 0
原创粉丝点击