java中线程的进一步学习

线程

1.常用方法
static void yield()： ： 线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法

join() ： ： 当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行

stop(): 强制线程生命期结束，不推荐使用

boolean isAlive()： ： 返回boolean，判断线程是否还活着

package xiancheng1;

public class Demo {
    public static void main(String[] args) {
        Hello h = new Hello();

        h.setName("分线程");

        h.start();

        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 100 ; i++) {
            if (i % 2 == 0){
                System.out.println( Hello.currentThread().getName() + ":" + i);
            }

            if (i == 30){
                try {
                    h.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        System.out.println(h.isAlive());//false


    }
}

class Hello extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100 ; i++) {
            if (i % 2 == 0){
                System.out.println( Hello.currentThread().getName() + ":" + i);
            }

        }
    }
}

2.线程的调度
同优先级线程组成先进先出队列（先到先服务），使用时间片策略

对高优先级，使用优先调度的抢占式策略

3.线程的优先级
线程的优先级等级
MAX_PRIORITY ：10
MIN _PRIORITY ：1
NORM_PRIORITY ：5 -默认的优先级

涉及的方法
getPriority() ： ：返回线程优先值
setPriority(int newPriority) ： ：改变线程的优先级

线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

package xiancheng1;

public class Demo01 {
    public static void main(String[] args) {
        Te te = new Te();

        te.setName("小线程");

        te.setPriority(Thread.MAX_PRIORITY);
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        te.start();

        Thread.currentThread().setName("主线程");

        for (int i = 0; i < 100 ; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
            }
        }
    }
}

class Te extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100 ; i++) {
            if (i % 2 == 0){
                System.out.println(getName() + ":" + getPriority() + ":" + i);
            }
        }
    }
}

4.线程的死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

解决方法
专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步

5.sleep和wait的异同
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
不同点：
两个方法的声明位置不同:Thread类中声明sleep()，Object类中声明wait()。
调用的要求不同:sleep(）可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中。
关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中，sleep不会释放锁，wait会释放锁。

6.JDK5.0新增线程创建方式
新增方式一：实现Callable
 与使用Runnable相比， Callable功能更强大些
 相比run()方法，可以有返回值
 方法可以抛出异常
 支持泛型的返回值
 需要借助FutureTask类，比如获取返回结果

Future接口
 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
 FutrueTask是Futrue接口的唯一的实现类
 FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

package xiancheng1;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class Test implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100 ; i++) {
            if (i % 2 == 0){
                sum += i;
            }
        }
        return sum;
    }
}

public class Demo02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Test test = new Test();

        FutureTask<Integer> integerFutureTask = new FutureTask<>(test);

        new Thread(integerFutureTask).start();

        Integer sum = integerFutureTask.get();

        System.out.println(sum);

    }
}

新增方式二：使用线程池
背景： 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前 创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：
 提高响应速度（减少了创建新线程的时间）
 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 便于线程管理
 corePoolSize：核心池的大小
 maximumPoolSize：最大线程数
 keepAliveTime：线程没有任务时最多保持多长时间后会终止
 …

7.线程池相关API
JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
 void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
 Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable
 void shutdown() ：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
 Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
 Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
 Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
 Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

package xiancheng1;

import java.util.concurrent.*;

public class Demo03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        Test1 test1 = new Test1();
        Test2 test2 = new Test2();


        executorService.execute(test1);
        executorService.execute(test2);

        executorService.shutdown();

    }
}

class Test1 implements Runnable{
    @Override
    public void run() {
        Thread.currentThread().setName("线程一");
        for (int i = 1; i <= 100 ; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class Test2 implements Runnable{
    @Override
    public void run() {
        Thread.currentThread().setName("线程二");
        for (int i = 1; i <= 100 ; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}