多线程

同步和异步有何异同,在什么情况下分别使用他们?举例说明。
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。

下面两个方法同步吗?(自己发明)

class Test{
      synchronized static void sayHello3(){}   
      synchronized void getX(){}
}

多线程有几种实现方法?同步有几种实现方法?
多线程有两种实现方法,分别是继承Thread类与实现Runnable接口
同步的实现方面有两种,分别是synchronized,wait与notify
wait():使一个线程处于等待状态,并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争。

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

当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法?
分几种情况:
1.其他方法前是否加了synchronized关键字,如果没加,则能。
2.如果这个方法内部调用了wait,则可以进入其他synchronized方法。
3.如果其他个方法都加了synchronized关键字,并且内部没有调用wait,则不能。
4.如果其他方法是static,它用的同步锁是当前类的字节码,与非静态的方法不能同步,因为非静态的方法用的是this。

线程的基本概念、线程的基本状态以及状态之间的关系
  一个程序中可以有多条执行线索同时执行,一个线程就是程序中的一条执行线索,每个线程上都关联有要执行的代码,即可以有多段程序代码同时运行,每个程序至少都有一个线程,即main方法执行的那个线程。如果只是一个cpu,它怎么能够同时执行多段程序呢?这是从宏观上来看的,cpu一会执行a线索,一会执行b线索,切换时间很快,给人的感觉是a,b在同时执行,好比大家在同一个办公室上网,只有一条链接到外部网线,其实,这条网线一会为a传数据,一会为b传数据,由于切换时间很短暂,所以,大家感觉都在同时上网。
  状态:就绪,运行,synchronize阻塞,wait和sleep挂起,结束。wait必须在synchronized内部调用。
调用线程的start方法后线程进入就绪状态,线程调度系统将就绪状态的线程转为运行状态,遇到synchronized语句时,由运行状态转为阻塞,当synchronized获得锁后,由阻塞转为运行,在这种情况可以调用wait方法转为挂起状态,当线程关联的代码执行完后,线程变为结束状态。

简述synchronized和java.util.concurrent.locks.Lock的异同 ?
主要相同点:Lock能完成synchronized所实现的所有功能
主要不同点:Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁,而Lock一定要求程序员手工释放,并且必须在finally从句中释放。Lock还有更强大的功能,例如,它的tryLock方法可以非阻塞方式去拿锁。
举例说明(对下面的题用lock进行了改写):

package com.huawei.interview;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadTest {
    private int j;
    private Lock lock = new ReentrantLock();
    public static void main(String[] args) {
        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 Subtractor implements Runnable{
        @Override
        public void run() {
            while(true){
            /*synchronized (ThreadTest.this) {          
                System.out.println("j--=" + j--);
                    //这里抛异常了,锁能释放吗?
                }*/
                lock.lock();
                try{
                    System.out.println("j--=" + j--);
                }finally{
                    lock.unlock();
                }
            }
        }
    }

private class Adder implements Runnable{
        @Override
        public void run() {
            while(true){
                /*synchronized (ThreadTest.this) {
                System.out.println("j++=" + j++);   
                }*/
                lock.lock();
                try{
                    System.out.println("j++=" + j++);
                }finally{
                    lock.unlock();
                }               
            }           
        }
    }
}

设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。
以下程序使用内部类实现线程,对j增减的时候没有考虑顺序问题。

package com.cy.pj;
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++;
    }
}

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

最终的程序代码如下:
public class ThreadTest {
    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{
        boolean bShouldSub = 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();          
        }
    }
 }

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

package com.huawei.interview.lym;

public class ThreadTest {

    private static boolean bShouldMain = false;

    public static void main(String[] args) {
        /*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();              
        }           
    }
}


你.LjWyH
30 声望3 粉丝

« 上一篇
数据库锁
下一篇 »
MVVM