Java线程

● 程序,进程,线程

程序 ：完成特定任务，用编程语言编写的一组指令。一段静态代码。

进程 ：指的是正在执行的程序，进程是操作系统进行资源分配的最小单元。

线程 ： 一个进程细分为线程，是进程内部的最小执行单元，线程属于进程。

进程与线程的关系：一个进程包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立。

● 创建线程

继承Thread类

/*
   MyThread 继承了Thread,所有MyThread拥有Thread类定义的管理线程的方法
 */
public class MyThread extends Thread{

    /*
       把我们想要在线程中执行的代码写在run()中
     */
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyThread:"+i);
        }
    }
}

public class TestThread {

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

        //在主线程中创建并启动子线程
        MyThread myThread = new MyThread();//创建线程对象
        //myThread.run(); //s注意直接调用run(),没有启动线程,只是一个普通的方法调用
        //启动线程
        myThread.start();

        //main线程中的for循环
        for (int i = 0; i < 1000; i++) {
            System.out.println("main:"+i);
        }
    }
}

实现Runnable接口

/*
   RunTask 实现Runnable接口,并没有继承Thread类,
   RunTask只是重写run(),可以编写线程中要执行的功能,本身并不是线程
 */
public class RunTask implements  Runnable{

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

public class Test {
    public static void main(String[] args) {
        RunTask runTask = new RunTask();//创建一个线程要执行的任务对象
        Thread thread  = new Thread(runTask);//创建了一个线程对象,并把线程要执行的任务交给线程对象
        thread.start();//启动线程时

        for (int i = 0; i < 1000; i++) {
            System.out.println("main:"+i);
        }
    }
}

● Thread类中方法

public class Test {

    public static void main(String[] args) {

        RunTask runTask = new RunTask();
       //Thread thread = new Thread(runTask);
        Thread thread = new Thread(runTask,"mythread1");
               //thread.setName("mythread2");
               thread.start();
               //由于现代的操作系统任务调度算法是综合性,不一定高优先级就一定先执行
               thread.setPriority(Thread.MAX_PRIORITY);//java支持对线程设置优先级的,优先级从1-10,默认是5

                        //currentThread()获取的就是main线程对象
       // System.out.println(Thread.currentThread().getId());
       // System.out.println(Thread.currentThread().getName());

        System.out.println(thread.getPriority());
        System.out.println(Thread.currentThread().getPriority());//main线程优先级
        /*
        void start() 启动线程
	 String getName() 返回线程的名称
	 void setPriority(int newPriority) 设置线程的优先级
	 int getPriority() 返回线程的优先级
	 void join() 等待线程终止
	 Thread currentThread() 返回对当前正在执行的线程对象的引用
	 void sleep(long millis) 让当前正在执行的线程休眠（暂停执行），休眠时间由milli s（毫秒）指定
	 yield() 线程让步
        */

● 线程状态

线程的状态：
● 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对
象处于新建状态
● 就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时
间片，此时它已具备了运行的条件，只是没分配到CPU资源
● 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run
（）方法定义了线程的操作和功能
● 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出
CPU并临时中止自己的执行，进入阻塞状态
● 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常
导致结束

● 守护线程

public class DaemonThread  extends Thread{

    @Override
    public void run() {
        int i = 0;
        while (true){
            System.out.println("DaemonThread:"+i++);
        }
    }
}

public class Test {

    public static void main(String[] args) {

          DaemonThread daemonThread = new DaemonThread();
          daemonThread.setDaemon(true);//设置线程为守护线程,必须在线程启动前设置
          daemonThread.start();

        for (int i = 0; i <1000 ; i++) {
            System.out.println("main:"+i);
        }
    }
}

● 多线程的概念

多线程是程序中包含多个执行单元，多个不同的线程来执行不同的任务。

多线程优缺点

优点 ：使程序响应速度快，提高CPU利用率，改善程序结构，将复杂任务分为多个线程，独立运行。当前没有进行处理的任务时可以将处理器时间让给其它任务。可以随时停止任务。

缺点 ：线程占用内存空间，线程越多占用空间越大。多线程需要协调和管理，所以需要CPU时间跟踪线程。线程对共享资源的访问会有影响，必须解决竞用共享资源的问题。

● 解决线程安全问题

使用synchronized同步代码锁

使用Lock

● synchronized和Lock锁的区别

ReentrantLock实现了Lock接口,所以可以称为lock锁 实现原理不同 ReentrantLock是一种java代码层面的控制实现 ,而synchronized是关键字,依靠的是底层编译后的指令实现 加锁范围不同

ReentrantLock只能对某一段代码块加锁,而synchronized可以对代码块和方法加锁 加锁释放锁方式不同

ReentrantLock需要手动的加锁释放锁,而synchronized是隐式的自动的加锁,自动释放锁(代码执行完了,出现异常了)

● 线程通信

线程通信是多个线程通过相互牵作用。

wait（），notify（），notifyAll（）三个方法是Object类定义的方法，必须是使用同步对象来进行调用。

wait（）让线程等待，必须通过唤醒才可以执行
notify（）唤醒被wait（）的线程
notifyAll（）唤醒所有被等待的线程

wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。

● wait()和sleep()区别

共同点：都可以让线程进入阻塞状态

sleep（）让线程阻塞指定时间后，自己唤醒进入就绪状态，不会释放同步锁，是Thead中的方法。
wait（）让线程进入阻塞或等待不会自己唤醒，必须通过notify（）或notifyALL（）来唤醒。等待时为方法锁，是Object类中的方法。

● 新增创建线程方式

实现Callable接口与使用Runnable相比，Callable功能更强大些. • 相比run（）方法，可以有返回值
• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，获取返回结果

import java.util.concurrent.Callable;

public class SumTask implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
          int sum = 0;
        for (int i = 0; i <10 ; i++) {
              sum += i;
        }
        return sum;
    }
}


import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test {
    public static void main(String[] args) {
         SumTask sumTask = new SumTask();
         FutureTask<Integer> futureTask = new FutureTask(sumTask);
         Thread thread = new Thread(futureTask);
                thread.start();
        try {
            Integer  sum =  futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}