Java多线程基础总结

刺骨的言语ヽ痛彻心扉 2022-09-24 14:16 233阅读 0赞

## 一、线程的概述 ##

进程：正在运行的程序，负责了这个程序的内存空间分配，代表了内存中的执行区域。  
线程：就是在一个进程中负责一个执行路径。  
多线程：就是在一个进程中多个执行路径同时执行。

a.多线程的好处：  
1.解决了一个进程里面可以同时运行多个任务（执行路径）。  
2.提供资源的利用率，而不是提供效率。  
b.多线程的弊端:  
1.降低了一个进程里面的线程的执行频率。  
2.对线程进行管理要求额外的 CPU开销。线程的使用会给系统带来上下文切换的额外负担。  
3.公有变量的同时读或写。当多个线程需要对公有变量进行写操作时,后一个线程往往会修改掉前一个线程存放的数据，发生线程安全问题。  
4.线程的死锁。即较长时间的等待或资源竞争以及死锁等多线程症状。

## 二、创建方式 ##

a.继承Thread类

/**
     * 
     * @author QiShui 方式一，重写run方法，调用start转变为可执行状态
     */
    class MyThread extends Thread {
    
        @Override
        public void run() {
            super.run();
    
            for (int i = 0; i < 20; i++)
                // Thread.currentThread().getName()获得子线程名字
                System.out.println(Thread.currentThread().getName() + i);
        }
    
    }
    
    public class TestDemo {
        
    
        public static void main(String[] args) {
    
            // 使用子线程
            MyThread myThread = new MyThread();
            myThread.start();
            /**
             *
             * JVM中至少有两个线程，主线程，和垃圾回收线程
             */
            for (int i = 0; i < 20; i++)
                // Thread.currentThread().getName()获得主线程名字
                System.out.println(Thread.currentThread().getName() + i);
    
    
        }
    
    }

注意：子线程与主线程抢占资源，才不是普通方法。

![这里写图片描述][20160801222020977]

b.实现Runable接口

/**
     * 
     * @author QiShui
     *
     */
    class MyTest implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 20; i++)
                // Thread.currentThread().getName()获得子线程名字
                System.out.println(Thread.currentThread().getName() + i);
        }
    }
    
    public class TestDemo2 {
        
    
        public static void main(String[] args) {
            //简单调用
            new Thread(new MyTest(),"testThread-1  ").start();
    
            // 详细说明
            MyTest test = new MyTest();
            // 传入实现Runable类的对象，给他起名，并不是线程对象的名字。
            Thread thread = new Thread(test, "testThread-2   ");
            thread.start();
            /**
             *   注意：
             *   当thread调用start方法时，会调用自己的run方法，在方法里面
             *   由于Runable不为空，调用的是MyTest类里的run方法 底层代码。
             * 
             * private Runnable target;
             * 
             * @Override 
             *  public void run() 
             *  { 
             *         if (target != null)
             *            { target.run(); } 
             *   
             *  }
             * 
             */
    
    
        }
    
    }

![这里写图片描述][20160801223926583]

## 三、线程的状态及生命周期分析 ##

创建：新创建了一个线程对象。  
可运行：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取cpu的执行权。  
运行：就绪状态的线程获取了CPU执行权，执行程序代码。  
阻临时塞: 阻塞状态是线程因为某种原因，如调用sleep,wait放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。  
死亡：线程执行完它的任务时。

![这里写图片描述][20160801224215039]

## 四、线程中常见的方法 ##

/**
     * 常见方法
     * @author QiShui
     *
     */
    
    public class TestDemo3 extends Thread {
        
        /*
         * Thread(String name) 初始化线程的名字 getName() 返回线程的名字 setName(String name)
         * 设置线程对象名 sleep() 线程睡眠指定的毫秒数。 getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
         * setPriority(int newPriority) 设置线程的优先级
         * 虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。 currentThread()
         * 返回CPU正在执行的线程的对象
         */
    
        public TestDemo3(String name) {
            //调用父类方法
            /**
             * public Thread(String name) {
             *       init(null, null, name, 0);
             *        }
             */
            super(name);
        }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            super.run();
    
            for(int i=0;i<10;i++){
                System.out.println("Hello ,World !!");
            }
    
        }
    
        public static void main(String[] args) {
    
            TestDemo3 testDemo3 = new TestDemo3("xiaoHuang");//初始化线程名字
    
    
            testDemo3.setName("LaoWang");//设置线程名字
    
            String name = testDemo3.getName();//获取线程名字
    
            System.out.println(name);
    
            int priority2 = testDemo3.getPriority();//获取线程优先级，默认是是5
    
            System.out.println(priority2);
            /**
             * 设置线程优先级，最低是1，最高为10，只是执行在前的概率大一点点
             */
            testDemo3.setPriority(8);
    
            System.out.println(testDemo3.getPriority());
            /**
             * 线程睡眠3s,此时为阻塞状态
             */
            try {
                testDemo3.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            testDemo3.start();
            //正在执行的对象
            Thread currentThread = testDemo3.currentThread();
            System.out.println(currentThread);
    
        }
    
    }

![这里写图片描述][20160801230327163]

[20160801222020977]: /images/20220719/c1cdffac5b744f63ab50581c2a3f27c7.png
[20160801223926583]: /images/20220719/55d88e7516614ab2a24374c73e2aaa49.png
[20160801224215039]: /images/20220719/ef56be35a5ac472f810cd8cbf6e59466.png
[20160801230327163]: /images/20220719/9a6a01f7201a424eab2960ddbd4ece7a.png