【java基础】线程

java基础 线程

参考详细:Java之多线程

一、创建线程

创建线程常见有两种方式,另外有两种新增方式

1.Thread

    /**
    新建线程方式一:继承Thread,重写run()
     */
    public static void test1(){
        Thread1 thread1 = new Thread1();
        thread1.setName("thread1");
        thread1.start();
    }

    static class Thread1 extends Thread{
        int i;
        @Override
        public void run() {
            while (i < 100){
                ++i;
                System.out.println(this.getName() + " 优先级 "+this.getPriority()+":" + i);
            }
        }
    }

2.Runnable

     /**
     * 新建线程方式二:实现Runnable,实现run();将Runnable作为Thread创建的实参
     */
    public static void test2(){
        Runnable runnable = new Runnable() {
            int i;
            @Override
            public void run() {
                while (i < 100){
                    ++i;
                    System.out.println(Thread.currentThread().getName() + " 优先级 "+Thread.currentThread().getPriority()+":" + i);
                }
            }
        };
        Thread thread2 = new Thread(runnable,"thread2");
        thread2.start();
    }

3.Callable --- JDK5.0新增

     /**
     * 新增·方式三:实现Callable接口,此功能支持有泛型返回值,支持抛出异常,需借助FutureTask类
     */
    public static void test3() throws ExecutionException, InterruptedException {
        Callable callable = getCallable();
        FutureTask futureTask = new FutureTask<>(callable);
        Thread thread3 = new Thread(futureTask);
        thread3.start();

        // 返回值
        Integer integer = futureTask.get();
        System.out.println("方式三:main获得结果-"+integer);
    }

    private static Callable getCallable(){
        Callable callable = new Callable() {
            int i;
            @Override
            public Integer call() throws Exception {
                while (i < 100){
                    ++i;
                    System.out.println(Thread.currentThread().getName() + " 优先级 "+Thread.currentThread().getPriority()+":" + i);
                }
                return i;
            }
        };
        return callable;
    }

4.ThreadPool --- JDK5.0新增

     /**
     * 新增·方式四:使用线程池创建线程
     */
    public static void test4() throws ExecutionException, InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(5);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
        Callable callable = getCallable();
        Future future = service1.submit(callable);
        System.out.println("方式四:main获得结果-"+future.get());
        service.shutdown();
    }

     private static Callable getCallable(){
        Callable callable = new Callable() {
            int i;
            @Override
            public Integer call() throws Exception {
                while (i < 100){
                    ++i;
                    System.out.println(Thread.currentThread().getName() + " 优先级 "+Thread.currentThread().getPriority()+":" + i);
                }
                return i;
            }
        };
        return callable;
    }

步骤:

1)提供指定线程池
ExecutorService service = Executors.newXXXThreadPool()

设置线程池属性
ThreadPoolExecutor service1 = ()service;
service1.setXXX

2)执行指定线程的操作,需要提供实现Runnable接口或Callable接口库实现类的对象
service.execute(xxx); // xxx为实现Runnable接口的类的对象
service.submit(xxx); // xxx为实现Callable接口的类的对象,返回结果Future类

3)关闭连接池
service.shutdown();

二、线程属性方法

1.Thread类的有关方法

1)start():启动当前线程,调用当前线程的run()
2)run():通常需要重写Thread类中的此方法,将创建的线程需要处理的逻辑写在这里
3)currentThread():静态方法,返回执行当前代码的线程 this = Thread.currentThread()
4)getName():获得当前线程的名字
5)setName():设置当前线程的名字
6)yield():释放当前cpu的执行权
7)join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完成以后,线程a就是阻塞状态
8)stop():已过时。当执行此方法,强制结束当前线程
9)sleep(long millitime):让当前线程“睡眠”指定millitime毫秒。在指定的毫秒内,当前线程阻塞状态。
10)isAlive():判断当前线程是否存活

2.线程优先级

1)等级:
MAX_PRIORITY:10,MIN_PRIORITY:1,NORM_PRIORITY:5
2)如何获取和设置当前线程优先级
getPriority():获取当前线程优先级
setProority(int p):设置当前线程优先级
高优先级线程要抢占低优先级线程cpu执行权。但是只是从概率上讲。

3.生命周期

线程生命周期.png

yield()

  • yield() 让当前正在运行的线程回到可运行状态,以允许具有相同优先级的其他线程获得运行的机会。因此,使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是,实际中无法保证yield()达到让步的目的,因为,让步的线程可能被线程调度程序再次选中

4.线程通信

方法

1)wait():使得调用wait()的线程进入阻塞状态,并释放同步监视器
2)notify():一旦执行此方法,就会唤醒被wait的一个线程。如果多个线程被wait,唤醒优先级高的
3)notifyAll():一旦执行此方法,就会唤醒被wait的所有线程

说明

1)wait(),notiry(),notiryAll()需要声明在同步代码块或者同步代码方法中
2)wait(),notiry(),notiryAll()调用者必须是同步代码块或者同步代码方法的同步监视器,否则会出现异常
3)wait(),notiry(),notiryAll()声明在java.lang.Object当中

sleep() VS wait()

  • sleep() 方法是线程类(Thread)的静态方法,调用此方法让当前线程暂停执行指定的时间,将执行机会(CPU)让给其他线程,但是对象的锁依然保持,因此休眠时间结束后会自动恢复(线程回到就绪状态)
  • wait() 是Object类的方法,调用对象的wait()方法导致当前线程放弃对象的锁(线程暂停执行),进入对象的等待池(wait pool),只有调用对象的notify()方法(或notifyAll()方法)时才能唤醒等待池中的线程进入等锁池(lock pool),如果线程重新获得对象的锁就可以进入就绪状态

总结

  • 不同:sleep()锁在,wait()锁不在。sleep()时间结束自动恢复;wait()等待notify()(或notifyAll()方法)唤醒
  • 同:调用方法进入阻塞状态

三、线程同步机制

1.同步代码块

synchronized(同步监视器){
      //需要同步的代码
}

同步监视器:类的对象
要求:多个线程必须要共用同一把锁,可以考虑使用this,类.class等

2.同步方法

synchronized添加到方法
synchronized method():同步监视器是this
static synchronized method():同步监视器是类.class

3.Lock锁 --- JDK5.0新增

  • 从JDK 5.0开始,Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock类实现了Lock,它拥有与 synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是 Reentrantlock,可以显式加锁、释放锁
class A {
    //1.实例化ReentrantLock对象
    private final ReenTrantLock lock = new ReenTrantLook();
    public void m (){
        lock.lock//2.先加锁
        try{
            //保证线程同步的代码
        }finally{
            lock.unlock();//3.后解锁
        }
    }
}

//注意:如果同步代码块有异常,要将unlock()写入finally语句块中

你可能感兴趣的:(【java基础】线程)