您的位置:88bifa必发唯一官网 > 八八必发娱乐 > 三个线程 1 一个线程

三个线程 1 一个线程

发布时间:2019-05-23 08:46编辑:八八必发娱乐浏览(59)

    今天去了回客科技 笔试了一波。很遗憾啊,脑袋有思路 但是还没到手写代码很熟练的程度,基本功不到位。

    第一道:线程的题:三个线程 1 一个线程 -1 运算 。

    看到网上还有四个线程的,两个加法计算,两个减法运算。基本的思路都是一样的 ,注意看同步处理。

    下面贴出代码实现:

    public class AddTest {
    
    
        private static int i;
    
        private static Object object = new Object();
    
        public static void main(String[] args) {
    
    
            new Thread(() -> {
                synchronized (object) {
                    i  ;
                }
            }).start();
    
            new Thread(() -> {
                synchronized (object) {
                    i  ;
                }
    
            }).start();
    
            new Thread(() -> {
                synchronized (object) {
                    i  ;
                }
            }).start();
    
            new Thread(() -> {
                synchronized (object) {
                    i--;
                }
            }).start();
    //这里睡眠 等所有线程运行完毕 看最终的数值,2
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
    
        }
    }
    

     这里引申出来了其他问题的思考

    第1种:
    synchronized void add  修饰普通方法 等同于
    
    synchronized (this)
    
      public int i = 0;
    
        public void add(String threadName) {
            synchronized (this) {
                i  ;
                System.out.println(threadName   "加法运算:"   i);
            }
        }
    
    //上面代码等于如下代码:
    
       public synchronized void add(String threadName) {
    
                i  ;
                System.out.println(threadName   "加法运算:"   i);
    
        }
    

      

    第2种:
    synchronized static void add  修饰静态方法 等同于
    
    synchronized (*.class)
    
    说明:以上两种我分析为 synchornized 修饰普通方法和this 对应的是同一个实例对象。而修饰静态方法和class 是对应的同一个类的 唯一的class对象。这个是我的理解,有错误之处请各位指正。在此谢过
    
    第二道:一个线程加一运算,一个线程做减法运算,多个线程同时交替运行(延申的)
    
    第1种方法:使用Synchronized 实现
    
    public class Count {
        private int num = 0;
        private boolean flag = false; // 标识
    
        //加法
        public synchronized void add() {
            while (flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.num  ; //加
            System.out.println(Thread.currentThread().getName()   "........"   this.num);
            this.flag = true; //设置标识为true
            notifyAll(); //唤醒所有在线程池中冻结的线程,会把所有都唤醒
    
        }
    
        //减法
        public synchronized void sub() {
            while (!flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.num--; //减
            System.out.println(Thread.currentThread().getName()   "........"   this.num);
            this.flag = false; //设置标识为true
            notifyAll(); //唤醒所有在线程池中冻结的线程,会把所有都唤醒
        }
    }
    

     第2种 :使用Lock 锁实现

     

    public class CountLock {
    
        private int num = 0;
        private boolean flag = false; // 标识
        Lock lock = new ReentrantLock(); // 锁
        Condition add = lock.newCondition(); // 加法锁
        Condition sub = lock.newCondition();// 减法锁
    
        public void add() {
            lock.lock();// 锁上
            try {
                while (flag) {  //循环判断
    
                    add.await();
                }
                this.num  ;
                System.out.println(Thread.currentThread().getName()   "........"   this.num);
                this.flag = true; // 设置标识
                sub.signal(); // 唤醒指定线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void sub() {
            lock.lock();// 锁上
            try {
                while (!flag) {//循环判断
                    sub.await();
                }
                this.num--;
                System.out.println(Thread.currentThread().getName()   "........"   this.num);
                this.flag = false; // 设置标识
                add.signal(); // 唤醒指定线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
    

      

    调用的 main 方法:
    
        public static void main(String[] args) {
            //Count c=new Count();
            CountLock c=new CountLock();
    
            Thread t1=new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        c.add();
                    }
                }
            });
            Thread t2=new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true){
                        c.sub();
                    }
    
                }
            });
    
            t1.start();
            t2.start();
       //这里感觉线程少可以再启动 两个t3或者t4 来验证真实性
    
        }
    

      

    这里延申的知识点参考博客:
    

    八八必发娱乐,一个线程加一运算,一个线程做减一运算,多个线程同时交替运行--synchronized

    java synchronized修饰普通方法,修饰静态方法,修饰代码块,修饰线程run方法 比较

    本文由88bifa必发唯一官网发布于八八必发娱乐,转载请注明出处:三个线程 1 一个线程

    关键词: 八八必发娱乐