看到这个问题第一反应是不懂，然后查询了网上的一些说法，感觉略有不一。细看之下发现大家对这个问题的分析角度不太一样，就会出现不同的结果，在这里记一下我收集来的不同的角度和自己的例子，感觉这个题目还是蛮有意思的。
首先，同步锁有两种，JVM的synchronized和JDK的ReentrantLock；

然后，多个线程访问这个类的两个方法也有不同的形式，例如访问这个类的两个方法是通过同一个类的实例对象来访问还是通过不同的类的实例对象访问；

再者，一个类的两个方法加了同步锁，这两个被同步方法也没有说明是什么样的方法。他可能是类的普通实例方法，也可能是类中Runnable对象的run方法。
看到这里也许会觉得我对于问题过于的咬文嚼字，但是我想要探讨更多的可能，不同的情形有着不同的结果，而且这些不同的情形能开拓思路，让我们看问题能多个角度，也可以帮我加深多线程的理解。如果本文中有错误或者不恰当的例子，或者代码写的不严谨不规范风格不好，都可以留言提出。
一.synchronized
1.多个线程同时访问同一个类实例对象的两个同步方法：
package synchronizedTest;

public class Example1 {
	private int num = 0 ;
	(省略getter.setter，后同)
	public synchronized void method1() {
		System.out.println("同步方法1进入");
		for(int i = 0 ; i<10 ; i++) {
			System.out.print("同步方法1:"+num+"--");
			num++ ;
		}
		System.out.println("同步方法1结束");
	}
	
	public synchronized void method2() {
		System.out.println("method2进入:");
		for(int i = 0 ; i<10 ; i++) {
			System.out.print("method2:"+num+"--");
			num++ ;
		}
		System.out.println("method2结束");
	}
	
	public static void main(String[] args) {
		final Example1 example1 = new Example1() ;
		
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method1();
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method2();
			}
		}) ;
		try {
			thread2.join();
			thread1.join();			
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
	
}

输出结果：
method1进入
同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--method1结束
method2进入:
method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束

显然此时多个线程是不能访问同个类（的一个实例对象）的两个同步方法的
2.多个线程同时访问同一个类的不同实例对象的两个同步方法：

将上面的代码稍作修改，主函数中多new一个该类实例
final Example1 example2 = new Example1() ;

再修改thread2的run方法调用的类实例为example2
Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example2.method2();
			}
		}) ;

得到结果：
同步方法1进入
method2进入:
method2:0--method2:1--同步方法1:0--同步方法1:1--同步方法1:2--method2:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--method2:5--同步方法1:6--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--method2:7--同步方法1结束
method2:8--method2:9--method2结束

这时候显然，多个线程是能访问同个类（的不同实例对象）的两个同步方法的。
小结：这是因为synchronized是对象锁，即线程获得的锁是施加在一个实例对象上的，如果不同的线程访问的是同一对象上的不同的同步方法，那么显然不能同时进行。

如果是不同对象上的不同的同步方法，那么就是可以同时进行的。
3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法：
package synchronizedTest;

public class Example2 {
	private int num ;
	public Runnable runnable1 = new Runnable() {
		@Override
		public void run() {
			//同步锁
			synchronized (this) {
				System.out.println("线程1进入");
				for(int i = 0 ; i < 10 ; i ++) {
					System.out.print("线程1:"+num+"--");
				}
				System.out.println("线程1结束");
			}
		}
	};
	
	public Runnable runnable2 = new Runnable() {
		@Override
		public void run() {
			//同步锁
			synchronized (this) {
				System.out.println("thread2进入");
				for(int i = 0 ; i < 10 ; i ++) {
					System.out.print("thread2:"+num+"--");
				}
				System.out.println("thread2结束");
			}
		}
	};
	
	public static void main(String[] args) {
		Example2 example = new Example2() ; //创建一个对象
		new Thread(example.runnable1).start(); //同步方法1
		new Thread(example.runnable2).start(); //同步方法2
	}
}


输出结果：
thread2进入
线程1进入
thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--线程1结束
thread2结束

可见此时多个线程是能同时访问同个类的两个同步方法的。这是因为

synchronized(this){ //... }中锁住的不是代码块，即这个锁在run方法中，但是并不是同步了这个run方法，而是括号中的对象this,也就是说，多个线程会拿到各自的锁，就能够同时执行run方法。(在run方法前声明synchronized也是同样的效果)
new Thread(example.runnable1).start(); //同步方法1
new Thread(example.runnable2).start(); //同步方法2

打印出这个this对象，是两个不同的类实例对象：
synchronizedTest.Example2$1@65db6dfa
synchronizedTest.Example2$2@471fab

也说明了不同线程的实例对象不同，都是各自对象的锁，不可以认为是类似于例子1中的同一实例对象，而应该类似与例子2的不同类的实例对象
总结：分析synchronized同步锁的核心在于他是个对象锁，找清楚锁的对象
二.ReentrantLock锁

1.多个线程同时访问同一个类实例对象的两个同步方法：

将例子1的synchronized改为引入ReentrantLock
package ReentrantLockTest;

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

public class LockExample {
	private int num;
	private Lock lock = new ReentrantLock();

	public void method1() {
			lock.lock();
			System.out.println("同步方法1进入");
			for(int i = 0 ; i<10 ; i++) {
				System.out.print("同步方法1:"+num+"--");
				num++ ;
			}
			System.out.println("同步方法1结束");
			lock.unlock();
	}

	public void method2() {
		lock.lock();
		System.out.println("method2进入:");
		for (int i = 0; i < 10; i++) {
			System.out.print("method2:" + num + "--");
			num++;
		}
		System.out.println("method2结束");
		lock.unlock();
	}

	public static void main(String[] args) {
		final LockExample example = new LockExample() ;
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example.method1();
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example.method2();
			}
		}) ;
		
		try {
			thread2.join();
			thread1.join();
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}


输出结果：
同步方法1进入
同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--同步方法1结束
method2进入:
method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束

可见此时多个线程是不能访问同个类（的一个实例对象）的两个同步方法的
2.多个线程同时访问同一个类的不同实例对象的两个同步方法：

修改main函数的即可：
public static void main(String[] args) {
		final LockExample example1 = new LockExample() ;//两个实例
		final LockExample example2 = new LockExample() ;
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method1(); //实例1的同步方法1
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example2.method2();//实例2的同步方法2
			}
		}) ;
		
		try {
			thread2.join();
			thread1.join();
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

输出结果：
同步方法1进入
method2进入:
同步方法1:0--method2:0--method2:1--同步方法1:1--method2:2--同步方法1:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--同步方法1:6--method2:5--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--同步方法1结束
method2:7--method2:8--method2:9--method2结束


可见，多个线程是能访问同个类（的不同实例对象）的两个同步方法的。
总结：ReentrantLock和synchronized的前两个例子结论都相同
3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法：
package ReentrantLockTest;

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

public class Lockexample2 {

	private int num;
	private Lock lock = new ReentrantLock();
	
	public Runnable runnable1 = new Runnable() {
		@Override
		public void run() {
			lock.lock();//上锁
			System.out.println("线程1进入");
			for(int i = 0 ; i < 10 ; i ++) {
				System.out.print("线程1:"+num+"--");				
			}
			System.out.println("线程1结束");
			lock.unlock();
		}
	};
	
	public Runnable runnable2 = new Runnable() {
		@Override
		public void run() {
			lock.lock();//上锁
			System.out.println("thread2进入");
			for(int i = 0 ; i < 10 ; i ++) {
				System.out.print("thread2:"+num+"--");
			}
			System.out.println("thread2结束");
			lock.unlock();
		}
	};
	
	public static void main(String[] args) {
		Lockexample2 example = new Lockexample2();
		new Thread(example.runnable1).start(); 
		new Thread(example.runnable2).start(); 
		
	}
}


输出结果：
线程1进入
线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1结束
thread2进入
thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2结束


这里可以看到，与synchronized的第三个例子出现了不同的结果。在这个地方，ReentrantLock不允许多线程同时访问一个类的不同同步方法。

这里要注意的是ReentrantLock与synchronized不同，ReentrantLock的实现方式是要先创建ReentrantLock对象，然后用这个对象的方法来上锁。而一个类的实例中只有一个ReentrantLock对象：
private Lock lock = new ReentrantLock();

而本例中，线程的创建是建立在同一个类实例上的：
Lockexample2 example = new Lockexample2();
new Thread(example.runnable1).start(); 
new Thread(example.runnable2).start(); 

因此，ReentrantLock对象lock是同一个，因此第一个线程进入同步方法1后就获取了锁，第二个线程无法获取这个锁，只能等待。
如果换成是两个实例对象：
public static void main(String[] args) {
		Lockexample2 example = new Lockexample2();
		Lockexample2 example2 = new Lockexample2();
		new Thread(example.runnable1).start(); 
		new Thread(example2.runnable2).start(); 
		
	}

输出结果
线程1进入
thread2进入
线程1:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2结束
线程1:0--线程1结束


可见不同的实例对象中是不同的ReentrantLock对象，因此可以同时访问
小结：ReentrantLock锁的核心在与ReentrantLock对象是不是同一个
三.结论

重新看看这个问题：一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的两个方法吗？
现在应该比较清楚了，这个问题要分成synchronized和ReentrantLock两个情况：
一.对于synchronized

1.一个类中的两个方法都加了同步锁，多个线程不能同时访问这个类的同一实例对象的两个方法

2.一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的不同实例对象的两个方法

3.一个类中的两个方法**（Runnable的run方法）都加了同步锁，多个线程能**同时访问这个类的两个方法（不论是不是同一实例对象）
二.对于ReentrantLock

1.一个类中的两个方法都加了同步锁，多个线程不能同时访问这个类的同一实例对象的两个方法（不论同步加在实例方法中或是run方法中）

2.一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的不同实例对象的两个方法（不论同步加在实例方法中或是run方法中）

类中的三类方法

类中的三类方法：普通、静态（static）、常方法（const）



static：


静态成员变量必须要在类外进行初始化；
属于类但不属于对象，所以，计算类大小时，不算static成员变量大小；
所有对象共用一个变量时使用static声明的变量；
static 成员方法没有this指针，直接用类的作用域调用；
static成员方法与变量在类外定义均不用加staic,但要加类作用域；
普通成员方法可调用静态成员方法，static变量
static方法不能访问普通成员变量/方法（同一对象中的），只能访问其他static成员。




const


常方法可访问不可修改
const对象无法调用普通成员方法

问题1：static和const能共存吗？ 

不能，static是把this指针没了，而const是给this指针加const，这两者是矛盾的。 

问题2：常对象为什么不能调普通方法？ 

默认情况下，this指针是指向非常量版本的常量指针。我们不能把this绑定到一个常量对象上（即int *const 绑定到 int const）这样也就使我们不能在一个常量对象上调用普通成员函数。




mutable（突破const限制）

主要用于后来扩充时，从前写的常方法增加需求。（不过尽量还是不要使用） 

三种方法使用注意： 

 - 普通成员方法可调用静态成员方法，static变量 

 - static方法不能访问普通成员变量/方法（同一对象中的），只能访问其他static成员。 

 - const对象无法调用普通成员方法 

即普通方法都可调用（优先调普通），static只可调用同一对象static，const只可调const

在一个类中，可能出现三种方法，实例方法、静态方法和类方法，下面来看看三种方法的不同：

1、实例方法

实例方法的第一个参数必须是”self”，实例方法只能通过类实例进行调用，这时候“self”就代表这个类实例本身。通过”self”可以直接访问实例的属性。
class person(object):
    tall = 180
    hobbies = []
    def __init__(self, name, age,weight):
        self.name = name
        self.age = age
        self.weight = weight
    def infoma(self):
        print('%s is %s weights %s'%(self.name,self.age,self.weight))


Bruce = person("Bruce", 25,180)
Bruce.infoma()

输出：



Bruce is 25 weights 180

2、类方法

类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod装饰器。通过cls可以访问类的相关属性。
class person(object):

    tall = 180
    hobbies = []
    def __init__(self, name, age,weight):
        self.name = name
        self.age = age
        self.weight = weight
    @classmethod     #类的装饰器
    def infoma(cls):   #cls表示类本身，使用类参数cls
        print(cls.__name__)
        print(dir(cls))
#cls表示类本身
#person.infoma()  直接调用类的装饰器函数，通过cls可以访问类的相关属性
Bruce = person("Bruce", 25,180)   #也可以通过两步骤来实现，第一步实例化person，第二步调用装饰器
Bruce.infoma() 

代码的输出为，从这段代码可以看到，类方法可以通过类名访问，也可以通过实例访问：

person
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'hobbies', 'infoma', 'tall']
person
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'hobbies', 'infoma', 'tall']

3、静态方法

与实例方法和类方法不同，静态方法没有参数限制，既不需要实例参数，也不需要类参数，定义的时候使用@staticmethod装饰器。
同类方法一样，静态法可以通过类名访问，也可以通过实例访问。
class person(object):

    tall = 180
    hobbies = []
    def __init__(self, name, age,weight):
        self.name = name
        self.age = age
        self.weight = weight
    @staticmethod    #静态方法装饰器
    def infoma():     #没有参数限制，既不要实例参数，也不用类参数
        print(person.tall)
        print(person.hobbies)
#person.infoma()   #静态法可以通过类名访问
Bruce = person("Bruce", 25,180)   #通过实例访问
Bruce.infoma() 

这三种方法的主要区别在于参数，实例方法被绑定到一个实例，只能通过实例进行调用；但是对于静态方法和类方法，可以通过类名和实例两种方式进行调用。

python类里会出现这三个单词，self和cls都可以用别的单词代替，类的方法有三种，

一是通过def定义的 普通的一般的，需要至少传递一个参数，一般用self，这样的方法必须通过一个类的实例去访问，类似于c++中通过对象去访问；

二是在def前面加上@classmethod，这种类方法的一个特点就是可以通过类名去调用，但是也必须传递一个参数，一般用cls表示class，表示可以通过类直接调用；

三是在def前面加上@staticmethod，这种类方法是静态的类方法，类似于c++的静态函数，他的一个特点是参数可以为空，同样支持类名和对象两种调用方式；