java多线程1

• 线程是独立的执行路径
• 程序运行时，即使没有自己创建线程，后台也会有多个线程，如main主线程，gc线程
• main()是主线程，是系统的入口，用于执行整个程序
• 在一个进程中，若有多个线程，线程的运行由调度器安排调度，调度器与操作系统相关，先后顺序不能干预
• 对同一个资源操作时，会存在资源抢夺问题，需要加入并发控制
• 线程会带来额外的开销，如cpu调度时间，并发控制
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

1、线程

// 1、创建线程：继承Thread类，重写run方法，调用start开启线程
public class TestThread1 extends Thread{
    @Override
    public void run() {
        super.run();
        // run方法线程体
        for (int i=0;i<100;i++){
            System.out.println("学习:"+i);
        }
    }


    // 主线程
    public static void main(String[] args) {

        TestThread1 th1= new TestThread1();
        th1.run();

        for (int i=0;i<300;i++){
            System.out.println("java"+i);
        }

    }
}

// 2、实现Runnable接口，重写run方法
可实现对同一资源进行操作
public class TestThread2 implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<300;i++){
            System.out.println("java学习"+i);
        }
    }

    public static void main(String[] args) {
        // 创建runnable的实现类对象
        TestThread2 th2 = new TestThread2();
//   `创建线程对象，通过线程对象调用start方法`
        Thread thread = new Thread(th2);
        thread.start();

        for (int i=0;i<300;i++){
            System.out.println("java thread"+i);
        }
    }
}

2、静态代理

1、静态代理要求目标对象和代理对象实现同一个业务接口 2、目标对象（被代理对象）必须实现接口 3、代理对象在程序运行之前就已经存在——扩展功能Agent 4、支持目标对象灵活切换

public class StaticProxy {


    public static void main(String[] args) {
        You you = new You();
        Company company =new Company(you);
        // 代理对象调用方法
        company.getMarry();
    }
}
interface Wedding {
    void getMarry();

}
// 真实角色 实现同一个接口Wedding 
class You implements Wedding{

    @Override
    public void getMarry() {
        System.out.println("llalal结婚了llllaalalal");
    }
}
// 代理角色 
class Company implements Wedding{

    private Wedding target;

    public Company(Wedding target){
        this.target = target;
    }
    @Override
    public void getMarry() {
        before();
        this.target.getMarry();
        after();
    }

    private void before() {

        System.out.println("结婚之前");
    }

    private void after() {
        System.out.println("结婚之后");
    }

}

3、 Lambda表达式

函数式接口：一个接口中，只有一个需要实现的抽象方法

interface Test{
	public void ttest();
}

• 基础语法

(参数1，2...)->{
	方法体
}

// 参数部分：与实现接口中的参数一致，包括参数的类型和数量
// 方法体：注意是否有返回值，若接口中定义的方法有返回值，则实现的时候，返回值

     // 使用lambda表达式实现接口
        test t1 = (int i)->{
            System.out.println("i love you->"+i);
        };
        t1.getNum(5);
}

interface test{
    void getNum(int i);
}

4、 守护线程

• 线程分为用户线程和守护线程，一般线程都为用户线程
• 虚拟机JVM必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如：后台记录操作日志、垃圾回收机制、监控内存等

public class TestDaedom {
    public static void main(String[] args) {

        // 创建实现类对象
        God god = new God();
        Person person = new Person();
        //通过线程对象
        Thread thread = new Thread(god);
        thread.setDaemon(true);// true设置为守护线程，默认为false
        thread.start();

        new Thread(person).start();

    }
}