周报总结---多线程、反射

一、线程

1.进程和线程：

进程：一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；

线程：线程是进程中最小的执行单元，一个进程至少有一个线程。

注意：两个进程内存独立不共享；线程A和线程B，堆内存和方法区内存共享，但是栈内存独立，一个线程一个栈。

使用多线程目的为了提高程序的执行效率。

---

2.线程对象的生命周期：

1. 新建状态
2. 就绪状态
3. 运行状态
4. 阻塞状态
5. 死亡状态

3.创建线程的三种方式:

1.继承Thread类，重写run()方法

public class MyThread1 extends Thread{
    
    @Override
    public void run() {
        System.out.println("新线程启动了...");
    }

    public static void main(String[] args) throws Exception {
        MyThread1 myThread1 = new MyThread1();
        myThread1.start(); //启动线程
    }
}

2.实现Runable接口，重写Run()方法

public class MyThread1 implements Runnable{

    @Override
    public void run() {
        System.out.println("新线程2启动了...");
    }

    public static void main(String[] args) throws Exception {
        MyThread1 myThread1 = new MyThread1();
        new Thread(myThread1).start();
    }
}

以上两种创建方式的区别：

（1）.继承Thread:受限于单继承

（2）.实现Runable接口：实现类作为new Threa()参数，实现多个接口，实现资源的共享

3.实现Callable接口：

可以获取线程的返回值：

public class MyThread1 implements Callable {

    @Override
    public Object call() throws Exception {
        System.out.println("线程3启动了。。。");
        return "线程的返回值";
    }

    public static void main(String[] args) throws Exception {
        MyThread1 myThread1 = new MyThread1();  //实例化
        FutureTask<String> task = new FutureTask<String>(myThread1);
        Thread thread = new Thread(task);
        thread.start(); //启动线程
    }
}

 4.Thread类API

• sleep():线程休眠，会让线程处于阻塞状态，指定时间后，线程进入就绪状态
• yield():暂停正在执行的线程对象，让出资源给其他线程执行，方法执行会让当前线程从”运行状态“回到”就绪状态“。
• join()：t.join()方法会使所有线程都暂停并等待t的执行完毕后在执行
• interrupt():中断线程，仅仅发送了一个中断的信号，当碰到wait(),slep()方法时，清除中断标记，抛出异常。
• setDaemon:设置线程为后台（守护）线程。

5.线程同步

线程同步：当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

实现同步的方式：

1.基于synchornized（同步）实现

synchornized(锁){

        同步代码块

}

synchornized可以修饰方法体或者方法

2.基于lock实现

public class MyThread1 implements Runnable {
    private Lock lock = new ReentrantLock();
    
    public void run() {
        lock.lock();
        for (int i = 0; i < 10; i++) {
            System.out.println("lock上锁...");
        }
    }

    public static void main(String[] args) throws Exception {
        MyThread1 myThread1 = new MyThread1();
        Thread thread = new Thread(myThread1);
        thread.start();
    }
   
}

6.死锁

死锁：当多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才放行，从而导致两个或者多个线程都在等待对方释放资源，都停止执行的情况。

二、反射

反射：在运行状态中，对于任意一个类能够类中的所有属性和方法，对任意一个对象能够调用对象中的属性和方法，这种动态获取属性和方法的机制：反射

反射将类的各部分封装成对应的对象

反射的步骤：

public class Test1 {
    public static void main(String[] args) throws Exception {

        Class<Student> cla1 = (Class<Student>) Class.forName("com.xy7.Student"); //获取class类的实例对象

        Constructor<Student> constructor = cla1.getConstructor();//通过class类对象可以获取构造方法

        Student student = constructor.newInstance(); //通过无参构造创建对象

        System.out.println(student);
    }
}