Java线程

java多线程学习

---

一、什么是线程？什么是进程？两者又有什么区别？

二、线程的状态有哪些？

---

三、线程的实现

注意，当用start()实现多线程的时候，线程会实现并发执行，也就是那个线程抢到了cpu那个就执行。如果用run()方法，那就是线程1执行完之后才会只能线程2，就不会有并发。

3.1，使用继承Thread方法，实现三个线程并发

• 代码线程工具类实现

public class ThreadUtil extends Thread {        public String names;        public ThreadUtil(String name) {            super();            names = name;        }        //写一个构造方法，来接通主类        @Override        public void run() {            for (int i = 0; i < 5; i++) {                System.out.println(names+" :次数 "+i);            }        }}

• 引用类

public class MyThread {    public static void main(String[] args) {        ThreadUtil tu1 = new ThreadUtil("我是线程tu1");        ThreadUtil tu2 = new ThreadUtil("我是线程tu2");        ThreadUtil tu3 = new ThreadUtil("我是线程tu3");        tu1.start();        tu2.start();        tu3.start();    }}

• 打印结果：
  

---

3.2，使用Runnable接口

• Runnable工具类

public class MyRunnable implements Runnable{    public String names;    public MyRunnable(String name) {        super();        names = name;    }    //写一个构造方法，来接通主类    @Override    public void run() {        for (int i = 0; i < 5; i++) {            System.out.println(names+" :次数 "+i);        }    }}

-主类引用

public class MyThread {    public static void main(String[] args) {        MyRunnable tu1 = new MyRunnable("我是实现Runnable的线程tu1");        MyRunnable tu2 = new MyRunnable("我是实现Runnable线程tu2");        MyRunnable tu3 = new MyRunnable("我是实现Runnable线程tu3");        //切记这里不能直接，tu1.start()。你需要创建一个Thread对象来接受我们实现的线程对象        Thread tr1 = new Thread(tu1);        tr1.start();        Thread tr2 = new Thread(tu2);        tr2.start();        Thread tr3 = new Thread(tu3);        tr3.start();    }}

• 运行结果：成功：
  

---

四、线程的常用方法

4.1代码来验证这些方法

• 代码模块：

public class TextRunnable{    public static void main(String[] args) {        TextRunnables trR = new TextRunnables("线程名称");        Thread td1 = new Thread(trR);        //来验证是否启动状态        System.out.println("线程的状态1："+td1.isAlive());        td1.start();        System.out.println("线程的状态2："+td1.isAlive());        //下面代码含义在于测试线程的join（）强制执行的方法            for (int i = 0; i < 20; i++) {            //在主线程写一个循环，执行20次，然后当主线程执行到10的时候，强制执行子线程。如下            if (i==10) {                try {                    td1.join();                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }            }            System.out.println("主线程："+i);        }    }    static class TextRunnables implements Runnable{            public String names;            public TextRunnables(String name) {                names = name;            }            //写一个构造方法，来接通主类            @Override            public void run() {                for (int i = 0; i < 5; i++) {                    //获取线程的名称                    System.out.println("线程名称： "+Thread.currentThread().getName());                }            }     }}

• 1、获取线程的名称

`System.out.println("线程名称： "+Thread.currentThread().getName());

• 2、判断线程是否启动

TextRunnables trR = new TextRunnables("线程名称");        Thread td1 = new Thread(trR);        //来验证是否启动状态        System.out.println("线程的状态1："+td1.isAlive());//打印是未启动        td1.start();        System.out.println("线程的状态2："+td1.isAlive());//打印已经未启动

• 3、验证强制开启子线程join（）方法

//下面代码含义在于测试线程的join（）强制执行的方法            for (int i = 0; i < 20; i++) {            //在主线程写一个循环，执行20次，然后当主线程执行到10的时候，强制执行子线程。如下            if (i==10) {                try {                    td1.join();                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }            }            System.out.println("主线程："+i);        }    }

• 剩下的还有睡眠sleep()，还有一个礼让方法yieid（）方法，这里就不说了。
-

四、线程的优先级

代码模块

public class MyRunnable02 {     public static void main(String[] args) {         //然后我们创建三个线程。来引用线程的优先级         Thread t1 = new Thread(new TextRunnables(),"A");         Thread t2 = new Thread(new TextRunnables(),"B");         Thread t3 = new Thread(new TextRunnables(),"C");         //设置优先级         t1.setPriority(Thread.MAX_PRIORITY);         t2.setPriority(Thread.MIN_PRIORITY);         t3.setPriority(Thread.NORM_PRIORITY);         //开启线程         t1.start();         t2.start();         t3.start();        }        static class TextRunnables implements Runnable{                //写一个构造方法，来接通主类                @Override                public void run() {                    for (int i = 0; i < 5; i++) {                        //获取线程的名称                        try {                            Thread.sleep(1000);                            System.out.println("线程名称： "+Thread.currentThread().getName()+i);                        } catch (InterruptedException e) {                            // TODO Auto-generated catch block                            e.printStackTrace();                        }                    }                }         }    }

结果分析：优先级高，提高的是占CPU的效率，而非就一定谁的高就必须先执行

• 
  

---

五、线程的同步

5.1：什么时候需要用到同步呢？ 就是程序的资源需要给多个线程共享的时候，打个比方，火车站有5张车票 ,三个人去抢。如果没有任何管理的情况下，就会出现有人付过钱了但是没有获得票的结局。例如下方代码

public class MyRunnable02 {     public static void main(String[] args) {         //然后我们创建三个线程。来引用线程的优先级         TextRunnables fRunnables = new TextRunnables();         Thread t1 = new Thread(fRunnables);         Thread t2 = new Thread(fRunnables);         Thread t3 = new Thread(fRunnables);         //开启线程         t1.start();         t2.start();         t3.start();        }        static class TextRunnables implements Runnable{                //假设有五张牌                private int ticket = 5;                @Override                public void run() {                        for (int i = 0; i < 10; i++) {                            //如果还有票就继续抢                            if(ticket>0){                            //获取线程的名称                            try {                                //睡眠500毫秒抢一次                                Thread.sleep(500);                              } catch (InterruptedException e) {                                // TODO Auto-generated catch block                                e.printStackTrace();                            }                            //如果被抢走，就减少一张票数量                            System.out.println("车票剩余： "+ticket--);                        }                    }                }         }    }

运行结果

5.2：所以我们就要用到同步（synchronized）来分配资源，这样就好比有一个专门的售票员一样，一手交钱一手交货， 相比5.1中，也就是在处理车票数据的时候添加一个同步锁

public class MyRunnable02 {     public static void main(String[] args) {         //然后我们创建三个线程。来引用线程的优先级         TextRunnables fRunnables = new TextRunnables();         Thread t1 = new Thread(fRunnables);         Thread t2 = new Thread(fRunnables);         Thread t3 = new Thread(fRunnables);         //开启线程         t1.start();         t2.start();         t3.start();        }        static class TextRunnables implements Runnable{                //假设有五张牌                private int ticket = 5;                @Override                public void run() {                    //加一个同步代码块，这样就可以合理的分配资源，不会出现cpu抢占资源问题                    synchronized (this) {                        for (int i = 0; i < 10; i++) {                            //如果还有票就继续抢                            if(ticket>0){                            //获取线程的名称                            try {                                //睡眠500毫秒抢一次                                Thread.sleep(500);                              } catch (InterruptedException e) {                                // TODO Auto-generated catch block                                e.printStackTrace();                            }                            //如果被抢走，就减少一张票数量                            System.out.println("车票剩余： "+ticket--);                        }                    }                    }                }         }    }

运行结果

---

5.3：我们上面5.2用的是同步代码块，那我们用同步方法如何实现的，其实很简单，只需要声明一个同步的方法即可。如下：

public class MyRunnable02 {     public static void main(String[] args) {         //然后我们创建三个线程。来引用线程的优先级         TextRunnables fRunnables = new TextRunnables();         Thread t1 = new Thread(fRunnables);         Thread t2 = new Thread(fRunnables);         Thread t3 = new Thread(fRunnables);         //开启线程         t1.start();         t2.start();         t3.start();        }        static class TextRunnables implements Runnable{                //假设有五张牌                private int ticket = 5;                @Override                public void run() {                    //直接调用同步方法即可                     tell();                }                //写一个同步的方法                public synchronized void tell(){                    for (int i = 0; i < 10; i++) {                        //如果还有票就继续抢                        if(ticket>0){                        //获取线程的名称                        try {                            //睡眠500毫秒抢一次                            Thread.sleep(500);                          } catch (InterruptedException e) {                            // TODO Auto-generated catch block                            e.printStackTrace();                        }                        //如果被抢走，就减少一张票数量                        System.out.println("车票剩余： "+ticket--);                    }                }                }         }    }

运行结果：也是正确的运行，只是处理同步资源的时候，放在一个同步方法中去处理

---

六、什么是死锁？

打个比方，一对情侣，女方必须要求南方在北京买一套3000万的房子，男子缺必须在老家买个30万的别墅。两个人就开始相互争执，这就造成了问题的无法解决，就可以理解为死锁。解决的办法，就是双方的某一方，降低自己的要求，能使两者都接受就可以了。

七、线程的生命周期？

就那么多把。都是最基础的。想深入了解的小伙伴可以i多搜搜这方面的知识！特别是线程同步多多注意