目录

1. 进程、线程概念
2. 创建线程的方法
3. 线程常用方法
4. 线程同步：Sync

1 进程线程概念

• 1.1 进程

进程指的是一个程序，如正在运行的QQ.exe，进程是一个静态概念，而程序可以说是进程的动态概念。

• 1.2 线程

线程是一个进程中的不同执行路径，如QQ发送文字，发送图片是不同的线程。

2 创建线程的方法

public class ClassDemo01 {
    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("create thread by extends Thread class");
        }
    }
    static class MyRun implements Runnable{
        @Override
        public void run() {
            System.out.println("creat thread by implements Runnable Interface");
        }
    }
    public static void main(String[] args) {
        System.out.println("running ");
        new MyThread().start();
        new Thread(new MyRun()).start();
        new Thread(()->{
            System.out.println("Anonymous  inner class implement Thread ! by lambda");
        }).start();
    }
}

3 线程常用方法

• 3.1 yield()

当前线程谦让的退出一下，回到线程等待队列，running-> ready
工程中很少用

 static void testYield() {//yield 当前线程谦让的退出一下，进入等待队列（如果没有其他线程，则此线程会继续执行）
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("Yield=====" + i);
                if (1 % 10 == 0) Thread.yield();
            }
        }).start();
    }

• 3.2 sleep()

当前线程睡眠指定时间，转化为waiting状态，到达指定时间后，被线程调度器执行

 static void testSleep() {//sleep()  将占用的cpu让给别的线程，进入线程等待队列
        new Thread(() -> {
            try {
                System.out.println("begin...");
                Thread.sleep(5000);
                System.out.println("end ...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

• 3.3 join()

线程加入另一个线程，在线程T2中执行T1.join()，则将T1加入T2，线程T2在T1结束后再结束

    static void testJoin() {// join() :线程加入，在线程t2中调用t1.join(); 则t2线程等t1线程执行完毕后再执行。
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread t1 running "+i);
            }
        });

        Thread t2 = new Thread(()->{
            System.out.println("Thread t2 begin ....");
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Thread t2 end!");
        });
        t1.start();
        t2.start();
    }

• 3.4 注

stop()方法已被放弃，不建议使用，如果需要关闭线程，可以通过捕获线程Interrput异常，根据异常类型选择响应的操作。

4 线程同步Sync

多个线程访问同一资源时，需要使用锁的概念。不加锁可能会发生脏读。
synchronized关键字锁定的是对象（任意对象，注意不要使用String,Integer,Long对象）。

• 4.1 Sync使用

package juc;

public class Sync {
    private static int count = 0;
    private Object o = new Object();
//非静态函数
    public  void noStatic2(){
        synchronized (this){//锁定当前对象
            count--;
        }
    }
    public  void noStatic1(){
        synchronized (o){//Obeject 对象
            count--;
        }
    }
    public synchronized  void noStatic3(){//等同于synchronized (this)
        count--;
    }
//静态函数
    public synchronized  static void test2(){//synchronized (Sync.class)
        count--;
    }

    public static void test1(){
        synchronized (Sync.class){
            count--;
        }
    }
}

• 4.2 Sync特性

>synchronizeds
1. 锁的是对象  不是代码
2. 如果在方法上使用sychronized关键字 默认锁定的是this
3. 锁定方法和非锁定方法可以同时执行
4.锁升级：偏向锁-》自旋锁-》重量级锁

1. 可重入性
   可重复性，加同一把锁的方法可以相互调用，不会产生死锁
2. 异常释放锁
   加锁的方法中，如果遇到抛出异常会释放锁，建议对可能产生异常的代码try catch 捕获异常