线程、多线程讲解，线程运行原理；接口、类、抽象类之间的关系

一、多线程并发

含义：有一个公共的资源，有俩个或三个多个线程去访问这个公共的资源，其中至少有一个线程去修改这个资源。
线程安全： 是不专业的，我们叫线程同步：首先要有线程并发：（引用上面）再有线程同步（不做同步会产生不可预期的效果，当线程同步后才会达到预期的效果）。

Java线程：线程的同步-同步方法

线程的同步是保证多线程安全访问竞争资源的一种手段。

对于同步，在具体的Java代码中需要完成一下两个操作：
把竞争访问的资源标识为private；
同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。
当然这不是唯一控制并发安全的途径。
synchronized关键字使用说明
synchronized只能标记非抽象的方法，不能标识成员变量。

为了演示同步方法的使用，构建了一个信用卡账户，起初信用额为100w，然后模拟透支、存款等多个操作。显然银行账户User对象是个竞争资源，而多个并发操作的是账户方法oper(int x)，当然应该在此方法上加上同步，并将账户的余额设为私有变量，禁止直接访问。

	    /** 
	    * Java线程：线程的同步 
	    * 
	    * @author leizhimin 2009-11-4 11:23:32 
	    */ 
	    public class Test { 
	            public static void main(String[] args) { 
	                    User u = new User("张三", 100); 
	                    MyThread t1 = new MyThread("线程A", u, 20); 
	                    MyThread t2 = new MyThread("线程B", u, -60); 
	                    MyThread t3 = new MyThread("线程C", u, -80); 
	                    MyThread t4 = new MyThread("线程D", u, -30); 
	                    MyThread t5 = new MyThread("线程E", u, 32); 
	                    MyThread t6 = new MyThread("线程F", u, 21); 
	    
	                    t1.start(); 
	                    t2.start(); 
	                    t3.start(); 
	                    t4.start(); 
	                    t5.start(); 
	                    t6.start(); 
	            } 
	    } 
	    
	    class MyThread extends Thread { 
	            private User u; 
	            private int y = 0; 
	    
	            MyThread(String name, User u, int y) { 
	                    super(name); 
	                    this.u = u; 
	                    this.y = y; 
	            } 
	    
	            public void run() { 
	                    u.oper(y); 
	            } 
	    } 
	    
	    class User { 
	            private String code; 
	            private int cash; 
	    
	            User(String code, int cash) { 
	                    this.code = code; 
	                    this.cash = cash; 
	            } 
	    
	            public String getCode() { 
	                    return code; 
	            } 
	    
	            public void setCode(String code) { 
	                    this.code = code; 
	            } 
	    
	            /** 
	             * 业务方法 
	             * @param x 添加x万元 
	             */ 
	            public synchronized void oper(int x) { 
	                    try { 
	                            Thread.sleep(10L); 
	                            this.cash += x; 
	                            System.out.println(Thread.currentThread().getName() + "运行结束，增加“" + x + "”，当前用户账户余额为：" + cash); 
	                            Thread.sleep(10L); 
	                    } catch (InterruptedException e) { 
	                            e.printStackTrace(); 
	                    } 
	            } 
	    
	            @Override 
	            public String toString() { 
	                    return "User{" + 
	                                    "code='" + code + '\'' + 
	                                    ", cash=" + cash + 
	                                    '}'; 
	            } 
	    }

输出结果：
线程A运行结束，增加“20”，当前用户账户余额为：120
线程F运行结束，增加“21”，当前用户账户余额为：141
线程E运行结束，增加“32”，当前用户账户余额为：173
线程C运行结束，增加“-80”，当前用户账户余额为：93
线程B运行结束，增加“-60”，当前用户账户余额为：33
线程D运行结束，增加“-30”，当前用户账户余额为：3

Process finished with exit code 0

反面教材，不同步的情况，也就是去掉oper(int x)方法的synchronized修饰符，然后运行程序，结果如下：
线程A运行结束，增加“20”，当前用户账户余额为：61
线程D运行结束，增加“-30”，当前用户账户余额为：63
线程B运行结束，增加“-60”，当前用户账户余额为：3
线程F运行结束，增加“21”，当前用户账户余额为：61
线程E运行结束，增加“32”，当前用户账户余额为：93
线程C运行结束，增加“-80”，当前用户账户余额为：61

Process finished with exit code 0

很显然，上面的结果是错误的，导致错误的原因是多个线程并发访问了竞争资源u，并对u的属性做了改动。

可见同步的重要性。

注意：
通过前文可知，线程退出同步方法时将释放掉方法所属对象的锁，但还应该注意的是，同步方法中还可以使用特定的方法对线程进行调度。这些方法来自于java.lang.Object类。

void notify()
唤醒在此对象监视器上等待的单个线程。
void notifyAll()
唤醒在此对象监视器上等待的所有线程。
void wait()
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
void wait(long timeout)
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。
void wait(long timeout, int nanos)
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

九种关系!

接口可以继承多个接口，不能实现，否则编译不通过
接口不能继承、实现抽象类。
接口不能继承、实现类。
抽象类只能实现接口（可以不实现接口里面的抽象方法）不能继承接口。
抽象类只能继承抽象类（单继承），不能实现。
抽象类只能继承类（单继承），不能实现。
类可以实现接口（多实现）
一个类只能继承一个抽象类
一个类继承一个类，要实现里面的所有方法，否则编译不通过。
抽象类和接口的使用：
1. 如果预计要创建组件的多个版本，则创建抽象类。抽象类提供简单的方法来控制组件版本；
2.如果创建的功能将在大范围的全异对象间使用，则使用抽象类。如果要设计小而简练的功能块，则使用接口；
3.如果要设计大的功能单元，则使用抽象类。如果要在组件的所有实现间提供通用的已实现功能，则使用抽象类；
4.抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。
abstract关键字：
1）用abstract关键字修饰一个类时，这个类叫做抽象类；用abstract关键字修饰一个方法时，这个方法叫关键方法；
2）含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写；
3）抽象类不能被实例化；
4）抽象方法只需声明，不需实现。