线程

进程和线程概念

• 进程：相对于系统来讲（Win Linux Mac），独立的内存空间，并发性，动态性
• 线程：相对于进程来讲，是进程内部的一个执行单元，内部单一的执行单元，顺序控制流程，共享进程资源

创建线程

• 1.继承Thread类，复写其run()方法，调用start()方法，启动线程

MyThread  t = new MyThread ();t.start();

• 2.实现Runnable接口，实现其run()方法，调用start()方法

MyThread mt =   new MyThread ();Thread t  =   new Thread(mt);t.start();

两种创建进程方法的比较

继承Thread类方式的多线程
- 优势：编写简单
- 劣势：无法继承其它父类

实现Runnable接口方式的多线程
- 优势：可以继承其它类，多线程可共享同一个Thread对象
- 劣势：编程方式稍微复杂，如果需要访问当前线程，需要调用Thread.currentThread()方法

调用start()方法启动线程和直接调用run()方法的区别

• 调用start()方法，会申请新的线程，开辟新的线程空间去执行run()方法中的内容
• 调用run()方法，只是由当前线程去调用run()方法，不会创建新的线程，仅将其当成一个普通方法调用

多线程的优势（重点）

• 多线程使系统空转时间减少，提高CPU利用率
• 进程间不能共享内存，但线程之间共享内存非常容易
• 使用多线程实现多任务并发比多进程的效率高
• Java语言内置多线程功能支持，简化了Java的多线程编程

线程状态

• 新生 创建新的线程对象
• 运行 调用start()方法
• 阻塞
  1.sleep(long time) 睡眠time毫秒后，自动唤醒继续运行
  2.join()加入 A线程加入到B线程，B线程等待A线程运行完毕再继续向下执行
  3.yield()暂停瞬间，然后继续执行
• 死亡 整个线程的run()方法的代码块运行完毕

线程锁

• synchronization(){ }同步代码块 多个线程中存在使用同一把锁的代码块，多个线程会抢这一把锁，抢到的进入同步代码块，剩下的线程全在外面阻塞，阻塞到进入的线程运行完，该线程会释放锁，所有阻塞的线程继续开始抢锁。
• 同步方法 public synchronized void xxx (){ }，同步方法的锁，就是锁住的对象就是调用该方法的对象
• 注意 ：在拥有同步方法的类中，锁住的是该类的实例化的对象

线程同步的必要性

线程间通信

• wait()和notify()
• 当执行了wait()方法后，本线程终止，将锁释放给正在等待该锁的线程
• 当执行了notify()方法后，线程会唤醒正在等待该锁的对象，但是唤醒后不是立即执行，而是等调用notify()方法的线程执行完同步代码块之后，才开始抢占执行。

Timer

• 定时器的使用
  
  • 首先要实例化Timer对象，
  • 然后要重写一个类继承TimerTask类，在复写其中的run()方法
  • 然后调用Timer()对象的schedule(TimerTask task, long delay, long period)
  • 第一个参数是继承TimerTask类的实例化对象
  • 第二个参数是延时多久开始执行其run()方法
  • 第三个参数是run()方法循环的间隔时间

public class Test {    public static void main(String[] args) {        Timer timer=new Timer();        timer.schedule(new MyTimerTask(), 2000 ,500);    }}public class MyTimerTask extends TimerTask{    private int i=0;    public void run() {        System.out.println("正在计时:"+i++);    }}

反射详解

• 反射就是可以通过对象实例或者类名来获取Class对象，通过Class对象的各种方法，可以获得该类的各种信息，包括属性，方法，构造器，返回值类型，属性类型等等。
• Class 类的抽象 Person Dog Car
  Field 属性的抽象
  Method 方法的抽象
  Constructor 构造器的抽象

• 可以通过反射的机制，给对象中的属性进行赋值操作

public class ReflectionTest {    public static void main(String[] args) {        Person zhangsan=new Person();        System.out.println(zhangsan.getName());        //此Person中不存在一个可以访问方法去修改名字        //可以使用反射去修改zhangsan这个对象的name        //1得到Person的Class对象        Class<Person> zhangsanClass=(Class<Person>) zhangsan.getClass();        try {            //2得到Person类中名称是name的字段            Field name=zhangsanClass.getDeclaredField("name");            //3取消反射时的java语言访问限制            name.setAccessible(true);            //4使用field修改zhangsan的name的值，因为Person中的name是private的，所以会报错,其他修饰符的话不会报错            name.set(zhangsan, "张三");            //5重新打开反射时的java语言访问限制，以后访问还要检查            name.setAccessible(false);            System.out.println(zhangsan.getName());        } catch (SecurityException e) {            e.printStackTrace();        } catch (NoSuchFieldException e) {            e.printStackTrace();        } catch (IllegalArgumentException e) {            e.printStackTrace();        } catch (IllegalAccessException e) {            e.printStackTrace();        }    }}public class Person {    private String name ;//zheshishenme a     private String sex;    public String getName() {        return name;    }    public String getSex() {        return sex;    }    public void setSex(String sex) {        this.sex = sex;    }}

设计模式

Dao模式

• 只有属性和set get方法

单例模式

• 在要单例化的类中
  
  • ① 私有化构造器，不允许外部使用new关键字创建对象
  • ② 声明一个静态的私有的Person对象
  • ③ 提供一个静态的公有的同步方法供外部访问，返回值类型是该类 为什么使用synchroized防止多个线程同时访问这个方法 静态同步方法的锁是指的类本身
  • ④ 在该方法中添加限制

public class Person {    private String name;    private String sex;    //创建一个静态的私有的该类对象，声明为静态只能有一个这个对象的实例    private static Person person;    //私有化构造器    private Person() {    }    //创建一个共有的静态的同步方法，声明为同步方法可以限制多个线程同时访问的问题，声明为静态可以通过类名调用    public synchronized static Person newInstance() {        //在其中添加限制，若不为空，就实例化对象，否则仅返回其对象        if (person==null) {            person=new Person();        }        return person;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getSex() {        return sex;    }    public void setSex(String sex) {        this.sex = sex;    }}public class Test {    //所有输出的内容hashcode是一样的，表示是同一个对象    public static void main(String[] args) {        Person zhangsan=Person.newInstance();        System.out.println(zhangsan);        Person lisi=Person.newInstance();        System.out.println(lisi);        new Thread(new Runnable() {            public void run() {                Person wangwu=Person.newInstance();                System.out.println(wangwu);            }        }).start();        new Thread(new Runnable() {            public void run() {                Person zhaoliu=Person.newInstance();                System.out.println(zhaoliu);            }        }).start();    }}

简单工厂模式

• 创建一个工厂，使用这个工厂创建这个类的对象
• 创建一个配置文件properties格式，用Properties类从中读取类的信息，根据类的信息用Class的forName(String str)，获取累的对象，
• 再用该对象实例化要生成的对象实例
• 要改变生成的对象实例时候，就不用重新编译代码，仅仅修改配置文件的类的信息就可以了
• 另外如果要扩展程序的话，对源代码基本不用改变，直接生成你要添加的类的代码即可

public class Person {    public void speak() {        System.out.println("人类会说话");    }}public class Teacher extends Person{    @Override    public void speak() {        System.out.println("老师会讲课");    }}public class PersonFactory {    public Person newInstance() {        Person person=null;        Properties pro=new Properties();        try {            //解析配置文件            pro.load(new FileInputStream("config.properties"));            //从配置文件中读取类的信息            String str=pro.getProperty("classname");            //Class类根据类名生成Class的对象            Class name=Class.forName(str);            //由Class对象生成对应类的实例            person=(Person) name.newInstance();        } catch (FileNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (ClassNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (InstantiationException e) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (IllegalAccessException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        return person;    }}public class Test {    public static void main(String[] args) {        PersonFactory factory=new PersonFactory();        Person person=factory.newInstance();        //根据生成对象的不同，输出相应改变        person.speak();    }}

• 配置文件如下
• 

知识漏洞

static

• 在一个类中，static修饰的类的属性，不管实例化多少个对象，该属性都只有一个，并且对每一个实例化对象共享。

PrintWriter

print()和println()的区别
- print()仅仅是打印输出
- println()打印输出，并且终止当前行的输出