进程与线程

并行与并发
并行：可以同时进行不同的任务
并发：交替的执行任务
高并发编程的意义、好处和注意事项
多线程：充分利用CPU的资源，加快相应的时间，可以使我们代码模块化、异步化、简单化
OS限制： Linux 1000个 windows 2000个
为什么要限制线程呢：需要分配栈空间
认识java里的线程
Java里的程序天生就是多线程的
几种新启线程的方式
Thread:对线程的抽象
Runnable: 对任务和业务逻辑的抽象

public class NewThread {

    private static class UseThread extends Thread{
        @Override
        public void run() {
            super.run();
            System.out.println("I am extendec Thread");
        }
    }

    public static class UseRunable implements Runnable {
        @Override
        public void run() {
            System.out.println("I am extendec Runnable");
        }
    }

    public static void main(String[] args)
                throws InterruptedException, ExecutionException {
        UseThread useThread=new UseThread();
        useThread.start();

        UseRunable useRunable=new UseRunable();
        new Thread(useRunable).start();
    }
}

关掉线程
stop() : 强制关掉线程，比较野蛮，不建议使用，可能会导致线程所占用的资源不会正常释放。
interrupt()：对线程发起一个中断，给线程的一个中断标志位，不代表要立即停止工作，线程可以完全不理会。
isInterrupted():判定是否被中断
interrupted()：boolean 静态方法，同样可以检测到中断标志位，但是被调用之后，会把isInterrupted()由true改成false.

private static class UseThread extends Thread{
        @Override
        public void run() {
            super.run();
//            System.out.println("I am extendec Thread");
            String threadName=Thread.currentThread().getName();
            System.out.println(threadName+"interrupt flag"+isInterrupted());
            while (!Thread.interrupted()){
                System.out.println(threadName+"is running");
                System.out.println(threadName+"inner interrupt flag = "+isInterrupted());
            }
            System.out.println(threadName+"interrupt flag"+isInterrupted());
        }
    }

结果：

注意：
jdk里面线程是协作式，而不是抢占式
死锁状态，不会理会中断

线程常用方法和线程的状态
Start和Run方法
start只能调用一次，多次调用会抛出异常。
run可以当成一个普通的方法调用。

public class StartAndRun {
    public static void main(String[] args) {
        ThreadRun threadRun=new ThreadRun();
        threadRun.setName("threadRun");
        threadRun.run();
    }

    public static class ThreadRun extends Thread{
        @Override
        public void run() {
            int i=10;
            while (i>0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("I am "+Thread.currentThread().getName()+" and now the i="+i--);
            }
        }
    }
}

可以看到调用run的是主线程而不是ThreadRun。
接下来用start方法试试。

public static void main(String[] args) {
        ThreadRun threadRun=new ThreadRun();
        threadRun.setName("threadRun");
        threadRun.start();
    }

可以看到调用的是线程本身。
以上就是start和run方法的最大区别。

了解yield()
yield(): 时间片到期，将线程从运行转为可运行状态。会让出当前cpu的执行权，但是让出的时间不可设定，并且此方法不会释放锁资源。
join()：获取执行权，能让线程顺序的执行。可以在需要插队时使用。

线程的优先级

useThread.setPriority(10);
useThread.setPriority(1);

需要休眠或者IO操作的可以把优先级设置的高一些，偏重于计算的可以设置的低一些，确保计算机不会被这些计算把时间占据了…

非守护线程：通过New thread 等手动启动的线程。
守护线程：jdk自己内部或者通过参数配置启动的线程。
守护线程中finally不一定起作用。

synchronized关键字的使用方法

public class SynTest {

    private long count=0;
    private Object obj=new Object();

    public long getCount(){
        return count;
    }

    public  void  setCount(long count){
        this.count=count;
    }

    //用在同步块上
    public void incCount(){
        synchronized (obj){
            count++;
        }
    }

    //用在方法上
    public synchronized void incCount2(){
        count++;
    }

    //count进行累加
    public void incCount3(){
        //this代表SynTest当前对象的实例
        synchronized (this){
            count++;
        }
    }

    private static class Count extends Thread{
        private SynTest simplOper;

        public Count(SynTest simplOper){
            this.simplOper=simplOper;
        }

        @Override
        public void run(){
            for(int i=0;i<10000;i++){
                simplOper.incCount();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
        SynTest simplOper=new SynTest();
        //启动两个线程
        Count count1=new Count(simplOper);
        Count count2=new Count(simplOper);
        count1.start();
        count2.start();
        Thread.sleep(50);
        System.out.println(simplOper.count);
    }
}

对象锁：执行某段代码的时候要拿到对象上的锁才能进行，如果有两个对象，每个对象有自己的锁，意味着两个线程可以并行的进行。
类锁：在一个静态方法上面加了一个锁。在打了static方法上进行加锁的话，意味着加锁的是一个class对象，本质上还是对象锁。并不是一个真正存在的东西，和对象锁之间互不干扰。

注意：synchronized锁的是一个具体对象