JAVA多线程一（线程创建的四种方式）

目录

多线程的创建

方式一

方式二     

方式三

方式四

---

概念：

程序（program）：完成特定任务、用某种语言编写的一段指令  是一段静态的代码、静态对象
进程（process）：正在动态运行的程序 ，动态的过程包括自身的产生、存在和消亡的过程简称生命周期
线程（thread）：进程的每一步操作细化为线程，具体负责执行执行命令的路径，单线程多线程

并行：同一时间多个不同任务同时执行
并发：同一时间一个任务多个执行

=========================================================================

线程分分为两类：守护线程、用户线程

关系： 守护进程是用来服务用户线程的，通过start()方法前调用thread.setDaemon(true)可以把一             个用户线程变成守护进程。

           java垃圾回收就是一个典型的守护线程。

           java中都是守护线程，当前JVM将退出。

=========================================================================

线程的调度策略
        时间片 ：  
        抢占式：设置线程优先级，抢占cpu
java调度方法
        同优先级线程先进先出原则，使用时间片策略
        高优先级使用优先调度抢占策略

=========================================================================

多线程的创建

方式一

         1、 继承Thread类
         2、 创建一个继承于Thread类的子类
         3、重写Thread类的run()
         4、创建Thread类的子类的对象
         5、通过对象调用start()

class ThreadOne extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i + "创建线程");
            }
         }
    }
}


 public static void main(String[] args) {
        ThreadOne t1 = new ThreadOne();
        //开启线程要调用start()方法 ，不能直接调run()方法
              t1.start();
        ThreadOne t2 = new ThreadOne();
        t2.start();
        for (int i = 0; i < 3; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i + "主线程main");
            }
        }
    }

注意：启动一个线程必须调用start()方法，不能调用run()的方式启动线程，start()方法包含了启动一个线程然后调用当前线程的run()，如果直接调用run(),没有线程执行不了。

方式二     

           1、创建一个实现Runnable接口的实现类
           2、实现类实现Runnable中的抽象方法run()
           3、创建实现类对象
           4、将此对象作为参数传递到Thread构造器中，创建Thread类对象
           5、通过Thread类的对象调用start()

public class ThreadPractice1 {
    public static void main(String[] args) {
        ThreadTicket1 tt = new ThreadTicket1();
        Thread t1 = new Thread(tt);
        Thread t2 = new Thread(tt);
        Thread t3 = new Thread(tt);
        t1.setName("窗口一=====");
        t2.setName("窗口二=====");
        t3.setName("窗口三=====");
        t1.start();
        t2.start();
        t3.start();
    }
}
class ThreadTicket1 implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "剩余票数：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

方式三

           实现Callable接口  jdk5.0新特性

public class ThreadPractice4 {
    public static void main(String[] args) {
        //创建Callable接口实现类对象
        Task4 task2 = new Task4();
        //将此Callable接口实现类的对象传递给FutureTask构造器中，创建FutureTask对象接收
        //FutureTask继承了Runnable接口
        //FutureTask futureTask = new FutureTask(task2);
        //泛型式加上返回类型
        FutureTask<Integer> futureTask= new FutureTask<Integer>(task2);
        //创建线程执行
        new Thread(futureTask).start();
        try {
            //get()返回值即为实现Callable接口的返回值
            //Object sum = futureTask.get();
            Integer sum = futureTask.get();
            System.out.println(sum);

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class Task4 implements Callable {

    @Override
    public Object call() throws Exception {
        int id = 0;
        for (int i = 0; i < 10; i++) {
            id += i;
            System.out.println(id);
        }
        return id;
    }
}

方式四

 

 

public class ThreadPractice5 {
    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        service1.getCorePoolSize();
        service1.getMaximumPoolSize();
        //执行线程的操作需要提供实现Runnable接口或者Callable接口实现类对象
        service.execute(new Task5());
        Task51 task51=new Task51();
        FutureTask task=new FutureTask(task51);

        service.submit(new Thread(task));
        //关闭连接池
        service.shutdown();
    }
}

class Task5 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("第" + i);
        }
    }
}

class Task51 implements Callable {

    @Override
    public Object call() throws Exception {
            int sum=0;
        for (int i = 0; i < 10; i++) {
            sum+=i;
            System.out.println("sum值" +sum);
        }
        return sum;
    }
}