线程和类关系

类和类之间的关系

1.  泛化关系。类和类之间的继承及接口和接口之间的继承 is a
2.  实现关系。接口与实现类之间的关系 is like a
3.  关联 类与类之间的连接，一个类可以知道另一个类的属性和方法 has a

 

class A{
     String name;
     B b;
     A(B b){
     this.b=b;
    }
}
class B{
     String name;
     A a;
}

      
     4.聚和 是关联关系的一种是较强的关联关系，是整体与部分之间的关系 整体不依赖部分，部分也不会依赖整体
     5.合成 比聚和关系强，区别在整体和部分是紧密相连的，整体的生命周期决定部分的。
     6.依赖 在一个类中创建另一个类的对象（注：通常是局部变量，形参）

 UML

•      继承 实线空心箭头指向父类
•      实现 虚线的空心箭头指向父类
•      关联 实线箭头指向被引用的一方
•      聚和 首先满足关联关系 空心菱形和实线 空心菱形在整体一端
•      合成 实心菱形加实线 实心菱形在整体一端
•      依赖 虚线加箭头

线程的同步（加锁）

1. Thread.sleep(毫秒)
2.  sleep方法是一个静态方法
3.  该方法的作用：阻塞当前线程腾出CPU、让给其他线程

异步编程模型

    t1线程执行t1的 t2线程执行t2的，两个线程之间不相互等待

 同步编程模型

    t1线程执行t1的 必须等某个线程执行结束之后才会执行另一个线程

    什么时候要同步?为什么要引入线程同步？
        1.为了数据的安全。
        2.多线程共享一个数据
        3.共享的数据涉及到修改操作
        synchronized(共享对象){}把需要同步的代码放到同步语句块中
        原理：
        t1线程和t2线程
        t1线程执行到此处遇到synchronize关键字就会去找this的对象锁
        如果找到this对象锁则进入同步语句块中执行程序，当同步语句块中的代码执行结束之后
        t1线程归还this的对象锁
        在t1线程执行同步语句块的过程中，如果t2线程也过来执行以下代码，也遇到synchronize
        关键字，所以也去找this的对象锁，但是该对象锁被t1线程持有，只能在这等待this对象的归还
        synchronize关键字加到成员方法上，线程拿走的也是this的对象锁
        synchronized添加到静态方法上，线程执行此方法的时候就会找类锁。
        死锁：
        羊群效应，哲学家吃饭
        setDaemon(true); 守护线程
        关于定时器的应用：
        1.创建定时器
        Timer t=new Timer();
        2.指定定时任务
        t.schedule(TimerTask task,new SimpleDateFormate("yyyy-MM-dd:ss SSS").parse("2017-03-28:00 000"),10*1000)

反射机制

java.lang.Class;                 
java.lang.reflect.Constructor;
java.lang.reflect.Filed;

类中的属性
public class User{
    private String id;
    public int age;
    protected String addr;
}
public class Reflect{
    public static void main(String []args){
    //获取整个类
        Class c=Class.forName("User");
        Field[]fs=c.getField();
        System.out.println(fs.length);
        System.out.println(fs[0].getName());
        Field[]fs=c.getDeclaredFields();

        for(Field field:fs){
        //获取修饰符
            int i=Field.getModifiers();
            System.out.println(i);
            String strModifer=Modifier.toString(i);
            System.out.println(strModifer);
        //获取属性类型
            Class type=field.getType();
            System.out.println(type.getSimpleName());
        //获取属性内容
            System.out.println(field.getName());
        }
    }
}

作用：
1.反编译 .class --> .java
2.通过反射机制访问java对象的属性，方法，构造方法

关于java语言中的可变长参数

Properties p=new Properties();
FileReader fr=nre FileReader("clssInfo");
p.load(fr);
fr.close();
String className=p.getProoerty("className");
Object o=c.newInstance();
Class c=Class.forName(className);
//创建对象，如果属性是私有的
Field f=c.getDeclaredField("id");
f.setAccessable(true);
f.set(o,"110");
String id=f.get(o)
//获取形参
Method []m=c.getDeclaredMethods();
Class[]paremeter=m.getParameterTypes()
//通过反射机制获取

public class Test
{
    public static void main(String []args){
        Num num=new Num(1);
        Thread t1=new Thread(new  printOdd(num));
        Thread t2=new Thread(new  printEven(num));
        t1.start();
        t2.start();
    }
}
class Num{
    int count;
    Num(int count){
        this.count=count;
    }
    public synchronized void printOdd(){
        System.out.println(Thread.currentThread().getName()+"---->"+count++);
        this.notifyAll();
        try{this.wait();}catch(Exception e){
            e.printStackTrace();
        }
    }
    public synchronized void printEven(){
        System.out.println(Thread.currentThread().getName()+"---->"+count++);
        this.notifyAll();
        try{this.wait();}catch(Exception e){
            e.printStackTrace();
        }
    }
}
class printOdd implements Runnable{
    Num num;
    printOdd(Num num){
        this.num=num;
    }
    public void run(){
        while(true){
            num.printOdd();
        }
    }
}
class printEven implements Runnable
{
    Num num;
    printEven(Num num){
        this.num=num;
    }
    public void run(){
    
        while(true){
            num.printEven();
        }
    }
}