Java多线程与并发库高级应用-传统线程互斥技术

Posted wq3435

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java多线程与并发库高级应用-传统线程互斥技术相关的知识,希望对你有一定的参考价值。

 

/**
 * 启动两个线程分别打印两个名字,名字按照字符一个一个打印
 * 
 * @author Administrator
 * 
 */
public class TraditionalThreadSynchronized {

    public static void main(String[] args) {
        new TraditionalThreadSynchronized().init();
    }

    public void init() {
        final Outputer outputer = new Outputer();// 内部类访问成员外部变量需要加final
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    outputer.output("aaaaa");
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    outputer.output("bbb");
                }
            }
        }).start();
    }

    class Outputer {
        public void output(String name) {
            int len = name.length();
            synchronized(this){   //使用静态代码块进行同步
                for (int i = 0; i < len; i++) {
                    char c = name.charAt(i);
                    System.out.print(c);
                }
            }
            System.out.println();
        }
    }

}

 

 以上涉及两个问题:

  内部类中使用外部类的成员变量需要加final 

  静态方法中不能 new 内部类的实例对象,why?

    内部类的重要特点,由于内部类可以访问外部类的成员变量,意味着外部类有了实例对象,静态方法执行时有一定有外部类的实例对象初始化。所以互相矛盾。

以上代码还可以有一种写法

class Outputer {
        public synchronized void output(String name) {
            int len = name.length();
//            synchronized(this){   //使用静态代码块进行同步
                for (int i = 0; i < len; i++) {
                    char c = name.charAt(i);
                    System.out.print(c);
                }
//            }
            System.out.println();
        }
    }

 

 直接将synchronized写法方法声明中,使用静态方法方式,内部使用的对象还是this

static class Outputer {
        public void output(String name) {
            int len = name.length();
            synchronized(Outputer.class){   //使用同步代码块进行同步  要想使output与output3进行同步,这里就不能使用this了,可以使用类的字节码
                for (int i = 0; i < len; i++) {
                    char c = name.charAt(i);
                    System.out.print(c);
                }
            }
            System.out.println();
        }
        public synchronized void output2(String name) {  //同步方法
            int len = name.length();
            for (int i = 0; i < len; i++) {
                char c = name.charAt(i);
                System.out.print(c);
            }
            System.out.println();
        }
        public static synchronized void output3(String name) {  //同步方法
            int len = name.length();
            for (int i = 0; i < len; i++) {
                char c = name.charAt(i);
                System.out.print(c);
            }
            System.out.println();
        }
    }

 

 

静态方法中不能跟this关联,跟类的字节码进行关联

 

以上是关于Java多线程与并发库高级应用-传统线程互斥技术的主要内容,如果未能解决你的问题,请参考以下文章

Java多线程与并发库高级应用-传统线程同步通信技术

(黑马Java多线程与并发库高级应用)04 传统线程同步通信技术

Java多线程与并发库高级应用-工具类介绍

Java多线程与并发库高级应用-工具类介绍

Java多线程与并发库高级应用-传统定时器技术回顾

(黑马Java多线程与并发库高级应用)02 传统定时器技术回顾