面向对象的多线程编程思想

面向对象思想是指：万物皆为对象，可以将事物抽象到一个类中，类中有对成员变量访问的方法。
面向对象的多线程编程思想即将多线程编程和面向对象思想相结合，具体来讲如下：

1、多个线程共享一个对象

多个线程难免会调用类中的方法，常用的使用方式即：多个线程共享一个类的一个对象，那么这个类的成员变量实际对于多个线程来说是共享的，因为共享一个对象，当然也共享该对象中的成员变量，因为成员变量和对象是一对一的关系。所以定义类中方法的时候，要考虑到方法是多个线程调用，那就会涉及到多线程读写共享变量的问题，这里的共享变量即为共享对象的成员变量，所以如果想保证线程安全，一定要在方法上加入synchronized（this），表示对调用该方法的对象上加锁，因为多个线程共享一个对象，所以自然可以实现多个线程间对共享成员变量的互斥访问。

2、多线程类中方法的设计思路

如上述所说，涉及访问成员变量的方法要加入synchronized保证互斥访问。除此之外，在设计方法时，要考虑到方法里的代码是被多个线程共用的，所以可以将方法内的代码直接代入到线程的run方法中来设计代码，会更容易些。

面向对象的多线程编程思想例子：

问题描述：三个线程，交替输出abc，一共输出5次。
输出效果：abcabcabcabcabc

public class TestTurnPrint {
    public static void main(String[] args) {
        WaitNotify wn= new WaitNotify(1,5);//多个线程共享这一份对象
        new Thread(()->{
            try {
                wn.print("a",1,2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                wn.print("b",2,3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                wn.print("c",3,1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}
/*
输出内容   等待标记   下一个标记
  a        1         2
  b        2         3
  c        3         1
*/
class WaitNotify{
    //等待标记
    private int flag;
    //循环次数
    private int loopNumber;
    //构造方法
    public WaitNotify(int flag,int loopNumber){
        this.flag=flag;
        this.loopNumber=loopNumber;
    }
    //核心方法-打印
    public void print(String str,int waitFlag,int nextFlag) throws InterruptedException {
        for(int i=0;i<loopNumber;i++){
            synchronized (this){
                while(flag!=waitFlag){
                    this.wait();
                }
                System.out.println(str);
                flag=nextFlag;
                this.notifyAll();
            }
        }
    }
}