Java线程的相关问题

            代码实例

            public
            class MyThread extends Thread{//继承Thread类publicvoid run(){
　　//重写run方法
　　}
}
publicclass Main {
   publicstaticvoid main(String[] args){
　　　　new MyThread().start();//创建并启动线程
　　}
}

            代码实例：

            public
            class MyThread2 implements Runnable {//实现Runnable接口publicvoid run(){
　　//重写run方法　　}
}
publicclass Main {
　　publicstaticvoid main(String[] args){
　　　　//创建并启动线程
　　　　MyThread2 myThread=new MyThread2();
　　　　Thread thread=new Thread(myThread);
　　　　thread().start();
　　　　//或者    new Thread(new MyThread2()).start();　　}
}

            代码实例：

            public
            class
             Main {
　　
            public
            static
            void
             main(String[] args){
　　　MyThread3 th=new MyThread3();
　　　//使用Lambda表达式创建Callable对象
　　   //使用FutureTask类来包装Callable对象
　　　FutureTask<Integer> future=new FutureTask<Integer>(
　　　　(Callable<Integer>)()->{
　　　　　　return5;
　　　　}
　　  );
　　　new Thread(task,"有返回值的线程").start();//实质上还是以Callable对象来创建并启动线程try{
　　　　System.out.println("子线程的返回值："+future.get());//get()方法会阻塞，直到子线程执行结束才返回
 　　 }catch(Exception e){
　　　　ex.printStackTrace();
　　　}
　　}
}

            /*
            *
     * synchronized添加到方法上面，使方法变成同步方法
     * 如果是静态方法，锁住的是class
     * 如果是普通方法，锁住的this,当前对象 synchronized(this)
     * 多个线程锁住的对象是同一个对象才能够同步，每个类都有当前对象
     
            */
            public
            static synchronized void salTicket(){
        if (ticketNum > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "买到第" + ticketNum-- + "张票");
            System.out.println(Thread.currentThread().getName() + "买票完成");
        }else {
            System.out.println("票已经售完，"+Thread.currentThread().getName() + "未买到票");
        }
    }

            /*
            *
     * 同步代码块
     
            */
            public
            void
             salTicket2() {
        synchronized (
            this
            ) {
            
            //
            ()中指定锁对象，this表示当前对象，多个线程使用同一个对象调用该方法时，是同步的
            
            //
            如果指定为 class，则该类的任意对象调用该方法都是同步的
            if (ticketNum > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "买到第" + ticketNum-- + "张票");
                System.out.println(Thread.currentThread().getName() + "买票完成");
            } else {
                System.out.println("票已经售完，" + Thread.currentThread().getName() + "未买到票");
            }
        }
    }

 //锁对象
 private static ReentrantLock lock=new ReentrantLock();

            /*
            *
     * 使用lock对象进行同步,多个线程使用的是同一个lock对象，才会是同步的
     
            */
            public
            void
             salTicket3() {
        
            lock.lock();//加锁if (ticketNum > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();//释放锁，必须放在finally代码块中，以确保能够释放锁                }
                System.out.println(Thread.currentThread().getName() + "买到第" + ticketNum-- + "张票");
                System.out.println(Thread.currentThread().getName() + "买票完成");
            } else {
                System.out.println("票已经售完，" + Thread.currentThread().getName() + "未买到票");
            }
    }

            //
            jdk中提供的四种快速创建线程池的方式
        
            //
            1.定长线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
        //2.缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        //3.周期线程池,可用来实现定时任务
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
        //4.单线程线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();