Java多线程线程创建及状态转换

r囧r小猫 2022-12-28 06:11 279阅读 0赞

### Java多线程 线程创建及状态转换 ###

*  1. 继承Thread
 *  2. 实现Runable
 *  3. 实现Callable
 *  4. 线程池
 *  5. 状态转换

# 1. 继承Thread #

/** * 线程类 * ThreadDemoTwo通过继承Thread * 获取线程名称：Thread.currentThread().getName() * * @author 20023262 * @date 2020/12/14 * @since 1.0 */
    public class ThreadDemoTwo extends Thread { 
    
        private String threadName;
    
        public
        ThreadDemoTwo(String threadName) { 
            this.threadName = threadName;
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("【" + threadName + "】" + Thread.currentThread().getName() + "运行，i = " + i);
            }
        }
    }

# 2. 实现Runable #

/** * 线程类 * ThreadDemoOne通过实现Runable接口 * 获取线程名称：Thread.currentThread().getName() * * @author 20023262 * @date 2020/12/14 * @since 1.0 */
    public class ThreadDemoOne implements Runnable { 
    
        private String threadName;
    
        public ThreadDemoOne(String threadName) { 
            this.threadName = threadName;
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("【" + threadName + "】" + Thread.currentThread().getName() + "运行，i = " + i);
            }
        }
    }

# 3. 实现Callable #

/** * 线程类 * ThreadDemoTwo通过实现Callable接口，这个是带返回值的 * 获取线程名称：Thread.currentThread().getName() * * @author 20023262 * @date 2020/12/14 * @since 1.0 */
    public class ThreadDemoThree implements Callable<String> { 
        @Override
        public String call() throws Exception { 
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + "线程运行");
            return Thread.currentThread().getName();
        }
    }

# 4. 线程池 #

package com.hello.thread;
    
    import com.google.common.util.concurrent.ThreadFactoryBuilder;
    import org.junit.Test;
    
    import java.util.concurrent.*;
    
    /** * 测试线程实现3种方式 * * @author 20023262 * @date 2020/12/14 * @since 1.0 */
    public class ThreadDemoTest { 
    
        // 自定义线程名称
        private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
        //定义线程池
        private static ExecutorService pool = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
    
    
        @Test
        public void threadDemoFourTest() throws ExecutionException, InterruptedException { 
    
            // 执行线程,execute()适用于实现Runnable接口创建的线程
            pool.execute(new ThreadDemoOne("线程A"));
    
            //submit()适用于实现Callable接口创建的线程
            Future<String> task = pool.submit(new ThreadDemoThree());
            String result = task.get();
            System.out.println("线程执行结果：" + result);
    
            // 关闭线程
            pool.shutdown();
    
        }
    
        /** * 测试实现Callable接口带返回值线程 */
        @Test
        public void threadThreeTest() throws ExecutionException, InterruptedException { 
            Thread.currentThread().setName("主线程");
            System.out.println(Thread.currentThread().getName() + "执行");
    
            //创建线程
            ThreadDemoThree threadDemoThree = new ThreadDemoThree();
            FutureTask<String> task = new FutureTask<>(threadDemoThree);
    
            Thread thread = new Thread(task);
            thread.setName("ThreadDemoThree");
            // 开启线程
            thread.start();
    
            // 获取结果
            String result = task.get();
            System.out.println("Callable执行返回结果：" + result);
    
    
        }
    
        /** * 测试继承Thread线程 */
        @Test
        public void threadTwoTest() { 
            // 线程A
            ThreadDemoTwo threadDemoTwoA = new ThreadDemoTwo("线程A");
            Thread threadA = new Thread(threadDemoTwoA);
    
            // 线程B
            ThreadDemoTwo threadDemoTwoB = new ThreadDemoTwo("线程B");
            Thread threadB = new Thread(threadDemoTwoB);
    
            // 启动线程
            threadA.start();
            threadB.start();
        }
    
        /** * 测试实现Runnable接口线程 */
        @Test
        public void threadOneTest() { 
            // 线程A
            ThreadDemoOne threadDemoOneA = new ThreadDemoOne("线程A");
            Thread threadA = new Thread(threadDemoOneA);
    
            // 线程B
            ThreadDemoOne threadDemoOneB = new ThreadDemoOne("线程B");
            Thread threadB = new Thread(threadDemoOneB);
    
            // 启动线程
            threadA.start();
            threadB.start();
        }
    
    }

# 5. 状态转换 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70]: /images/20221120/2ee2e0f029a94c0fb308f29b4109c1c0.png