JAVA基础之线程

 个人理解：

　　在相同的进程也就是运行同样的程序的前提下，线程越多效率越快！当然硬件也是个障碍！为了提高效率，可以多创建线程，但是也不是越多越好，这就需要了线程池进行管理！需要知道的线程实现的方法：继承thread类和实现runnable方法！了解其状态、启动是start

一、多线程介绍：

1、进程：

　　　　正在执行的程序；

2、线程：

　　　　进程中的一个执行单元，负责当前进程中程序的执行。

　　一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

3、单线程与多线程的比较：

　　单线程：多个任务依次执行，排着队来；

　　多线程：多个任务同时执行；

二、程序运行原理：

1、分时调度：

　　所有线程轮流使用cpu的使用权，平均分配每个线程占用cpu的时间；

2、抢占式调度：

　　优先让优先级高的线程使用cpu，优先级相同，则随机选择！（java就是占用的）

cpu使用抢占式调度模式在多个线程间进行高速的切换。某个时刻，只执行 一个线程。多个线程并不能提高程序的运行速度，但能提高程序运行效率，让cpu的使用率更高。

三、主线程：

　　jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。当程序的主线程执行时，如果遇到了循环而导致程序在指定位置停留时间过长，则无法马上执行下面的程序，需要等待循环结束后能够执行。

四、thread类：

　　　　程序中的执行线程！！！

public class mythread extends thread {

    public void run() {
        //获取当前线程的名称getname()
        system.out.println("线程名称为"+getname());
        for(int i=0;i<20;i++){
            system.out.println("mythread-"+i);
        }
    }
}

public class demo01 {
    public static void main(string[] args) {
        //获取指定当前代码的线程的线程对象（在main方法里必须先获得其对象，因为main方法是静态的，在其内部不能访问普通方法！）
        thread th=thread.currentthread();
        //获取该线程的名字
        system.out.println(th.getname());
        // 创建新线程---（需要描述任务和开启线程)
        mythread thread = new mythread();
        // 开启线程
        thread.start();
        for (int i = 0; i < 20; i++) {
            system.out.println("mian-" + i);
        }

    }
}

1、线程对象调用 run方法和调用start方法区别？

线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

2、创建线程的目的是什么？（多线程就是多个栈）

是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。

3、获取线程名称：

thread.currentthread().getname();获取当前线程对象的名称

五、实现runnable接口创建线程方式：

public class myrunnable implements runnable{

    public void run() {
        for(int i=0;i<20;i++){
            system.out.println("thread-"+i);
        }
        
    }
}

public class demo01 {
    public static void main(string[] args) {
        //创建线程任务对象（负责描述任务）
    myrunnable mr=new myrunnable();
    //创建thread对象(只需要开启线程）
    thread th=new thread(mr);
    //开启线程
    th.start();
    for(int i=0;i<20;i++){
        system.out.println("main-"+i);
    }
  }
}

1、原理：

　　实现runnable接口，避免了继承thread类的单继承局限性（不能继承其他的类了）。覆盖runnable接口中的run方法，将线程任务代码定义到run方法中。

　　建thread类的对象，只有创建thread类的对象才可以创建线程。线程任务已被封装到runnable接口的run方法中，而这个run方法所属于runnable接口的子类对象，所以将这个子类对象作为参数传递给thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

2、好处：

　　第二种方式实现runnable接口避免了单继承的局限性，所以较为常用。实现runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承thread类，线程对象和线程任务耦合在一起。一旦创建thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是runnable接口类型。runnable接口对线程对象和线程任务进行解耦。

3、匿名内部类使用：

public class demo02 {
    public static void main(string[] args) {
         /* 匿名内部类：
          new 子类或实现类名（）{
             需要重写的方法
         }*/
        //1.创建线程的方式：继承thread （重写run方法：打出run 后 alt+/)
        new thread(){
            public void run() {
                system.out.println(getname()+"这是新线程任务");
            }
        }.start();
        //2.实现runnable接口
        runnable run=new runnable(){
            public void run() {
                system.out.println(thread.currentthread().getname()+"这是第二种方式");
            };
        };
        new thread(run).start();
    }
}

六、线程状态：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

七、线程池：

 1、概念：

　　线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复的使用，

省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。（正常的话，其实就是在线程池的集合中remove线程，用完后再add回去）

2、runnable接口：

　　线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。

public class myrun implements runnable{

    public void run() {
        //获取执行当前线程对象的名字
        string name=thread.currentthread().getname();
        for(int i=0;i<20;i++){
            system.out.println(name+i);
            //不能throws
            try {
                thread.sleep(1000);//休眠
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
        }
        
        
    }
}

public class demo01 {
    public static void main(string[] args) {
        //创建线程任务对象
        myrun mr= new myrun();
        //创建新线程对象
        thread th =new thread(mr);
        //开启线程
        th.start();
    }
}

import java.util.concurrent.executorservice;
import java.util.concurrent.executors;

public class demo02 {
    public static void main(string[] args) {
        //用线程池的方式完成线程任务
        //1.从线程池工厂中获取一个装有两条线程的线程池对象
        executorservice es=executors.newfixedthreadpool(2);
        //2.创建线程任务
        myrun mr=new myrun();
        //3.让线程池自主选一条线程执行线程任务（第二个会等第一个的有空了就执行）
        es.submit(mr);
        es.submit(mr);
        es.submit(mr);
        /*//关闭线程池(一般不关闭）
        es.shutdown();*/
    }
}

3、callable接口：有泛型，与返回值类型相同

import java.util.concurrent.callable;

public class mycallable implements callable<string>{


    public string call() throws exception {

        return "abc";
    }

import java.util.concurrent.executionexception;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;

public class demo01 {
    public static void main(string[] args) throws interruptedexception, executionexception {
        //1.从线程池工厂中获取线程池对象
        executorservice es=executors.newfixedthreadpool(2);
        //2.创建线程任务对象
        mycallable mc=new mycallable();
        //3.让线程池自主选择一条线程执行线程任务
        future<string>    f=es.submit(mc);
        //4.获取线程任务的返回值
        system.out.println(f.get());
    }
}

 future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

 get() 获取future对象中封装的数据结果

import java.util.concurrent.callable;

public class mycall implements callable<integer>{
    private int num;
    private int num1;
    public mycall(){}
    public mycall(int num,int num1){
        this.num=num;
        this.num1=num1;
    }
    public integer call() throws exception {
        //计算求和
        int sum=0;
        for(int i=num;i<=num1;i++){
            sum+=i;
        }
        return sum;
    }
}

import java.util.concurrent.executionexception;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;

public class demo01 {
    //用线程池计算50.。。。100的和------44.....200的和
    public static void main(string[] args) throws interruptedexception, executionexception {
        //1.从线程池工厂获取线程池对象
        executorservice es=executors.newfixedthreadpool(2);
        //2.创建线程任务对象
        mycall mc1=new mycall(50,100);
        mycall mc2=new mycall(44,200);
        //3.让线程池自主选择线程执行任务
        future<integer> f1=es.submit(mc1);
        future<integer>    f2=es.submit(mc2);
        //4.获取线程任务返回值
        int sum1=f1.get();
        int sum2=f2.get();
        system.out.println(sum1);
        system.out.println(sum2);
    }
}