java 多线程总结-01

1- 创建线程

    在这里就不设计到线程池了，想了解线程池的请查看另一篇博文 https://blog.csdn.net/tanghui270270/article/details/80595961

1-1 继承Thread类

    

// 1- 创建线程方法1 继承Thread
new Thread("thread0"){
    @Override
    public void run() {
        // 这里的this就是Thread 的对象
        String name = this.getName();
        System.out.println(this.getName());
    }
}.start();

1-2 实现Runnable接口

// 2- 创建线程方法2 实现Runnable
Thread thread1 = new Thread(new Runnable() {
    @Override
    public void run() {
        //而这里的this 其实是 Runnable 的对象， 所以必须要获取当前线程的对象，才能调用Thread类中的一些方法
        System.out.println(Thread.currentThread().getName());
    }
}, "thread1");
thread1.start();

2- 线程中常用的方法

构造：new Thread() new Thread(name) new Thread(Runnable name) 
名称：getName()     setName()    
休眠线程： Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000
守护线程：
setDaemon(true/false)  设置为守护线程
isDaemon()测试该线程是否为守护线程
加入线程：
join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续   
join(int), 可以等待指定的毫秒之后继续
礼让线程:
Thread.yield(); 让出CPU
设置线程的优先级:
setPriority(Thread.MIN_PRIORITY); //设置最小的线程优先级

setPriority(Thread.MAX_PRIORITY); //设置最大的线程优先级

其他方法

getState()   返回该线程的状态
isAlive()    测试线程是否处于活动状态
interrupt()  中断线程
isInterrupted()  测试线程是否已经中断

3- 同步代码块

    

* 1.什么情况下需要同步

* 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.

* 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

* 2.同步代码块

* 使用synchronized关键字加上一个锁对象（同一个锁对象）来定义一段代码, 这就叫同步代码块

* 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

* 3.同步方法

        * 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的。

        * 非静态同步方法的锁对象是this （谁调用谁就是锁对象）

        * 静态同步方法的锁对象是该类的字节码对象

实例:

    同步代码块

package com.th.thread;

/**
 * Created by Administrator on 2018/6/7.
 */
public class TestSynchronized {

    public static void main(String[] args) {

        Print print1 = new Print();
        Print print2 = new Print();

        new Thread(){
            @Override
            public void run() {
                while ( true ){
                    print1.print1();
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while ( true ){
                    print1.print2();
                }
            }
        }).start();
    }
}


class Print{
   public void print1()  {
       // 同步代码块的所对象需要时同一个锁对象，如果不是同一个锁对象，也不是两个同步代码块不属于同一个同步代码块
       // 这里的锁对象是this 也就是说 谁调用这个方法，谁就是这个锁对象
       // 如果这两个方法不是同一个对象调用的，那么这两个同步代码块不属于同一个同步代码块（锁对象不一样）
       synchronized (this){
           System.out.print("一");
           System.out.print("二");
           System.out.print("三");
           System.out.print("四");
           System.out.print("五");
           System.out.print("\r\n");

       }
   }

   public void print2()   {
       // 同步代码块的所对象需要时同一个锁对象，如果不是同一个锁对象，也不是两个同步代码块不属于同一个同步代码块
       // 这里的锁对象是this 也就是说 谁调用这个方法，谁就是这个锁对象
       // 如果这两个方法不是同一个对象调用的，那么这两个同步代码块不属于同一个同步代码块（锁对象不一样）
       synchronized (this){
           System.out.print("1-");
           System.out.print("2-");
           System.out.print("3-");
           System.out.print("4-");
           System.out.print("5");
           System.out.print("\r\n");
       }
   }
}

非静态同步方法（锁对象是this）

package com.th.thread;

/**
 * Created by Administrator on 2018/6/7.
 */
public class TestSynchronized02 {

    public static void main(String[] args) {

        Print02 print1 = new Print02();
        Print02 print2 = new Print02();

        new Thread(){
            @Override
            public void run() {
                while ( true ){
                    print1.print1();
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while ( true ){
                    print1.print2();
                }
            }
        }).start();
    }
}

class Print02{
    // 非静态同步方法的锁对象是this(谁调用锁对象就是谁)
    public synchronized void print1()  {
        System.out.print("一");
        System.out.print("二");
        System.out.print("三");
        System.out.print("四");
        System.out.print("五");
        System.out.print("\r\n");
    }

    public void print2()   {
        // 同步代码块的所对象需要时同一个锁对象，如果不是同一个锁对象，也不是两个同步代码块不属于同一个同步代码块
        // 这里的锁对象是this 也就是说 谁调用这个方法，谁就是这个锁对象
        // 如果这两个方法不是同一个对象调用的，那么这两个同步代码块不属于同一个同步代码块（锁对象不一样）
        synchronized (this){
            System.out.print("1-");
            System.out.print("2-");
            System.out.print("3-");
            System.out.print("4-");
            System.out.print("5");
            System.out.print("\r\n");
        }
    }
}

静态同步方法（锁对象是字节码对象）

    

package com.th.thread;

/**
 * Created by Administrator on 2018/6/7.
 */
public class TestSynchronized03 {

    public static void main(String[] args) {

        Print03 print1 = new Print03();
        Print03 print2 = new Print03();

        new Thread(){
            @Override
            public void run() {
                while ( true ){
                    Print03.print1();
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while ( true ){
                    print1.print2();
                }
            }
        }).start();
    }
}

class Print03{
    // 静态同步方法的锁对象是该对象的字节码对象
    public static synchronized void print1()  {
        System.out.print("一");
        System.out.print("二");
        System.out.print("三");
        System.out.print("四");
        System.out.print("五");
        System.out.print("\r\n");
    }

    public void print2()   {
        // 这个同步代码块要跟上面静态同步方法同步 锁对象就要是该类的字节码对象
        synchronized (Print03.class){
            System.out.print("1-");
            System.out.print("2-");
            System.out.print("3-");
            System.out.print("4-");
            System.out.print("5");
            System.out.print("\r\n");
        }
    }
}

4- 多线程死锁

    两个线程+两个同步代码块（嵌套）+两个锁对象 = 有可能出现死锁的现象

package com.th.thread;

/**
 * Created by Administrator on 2018/6/7.
 * 两个线程 两个锁对象 两个同步代码块嵌套
 * 线程1 获取到第一个锁对象 线程2 获取到第二个锁对象 这个时候两个线程都在等另外一个锁对象，就出现了死锁的情况
 */
public class DeadLock {

    private static String s1 = "筷子1";
    private static String s2 = "筷子2";
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                while ( true ){
                    synchronized (s1){
                        System.out.println(Thread.currentThread().getName() + " : 获取" + s1 +"等待" + s2);
                        synchronized (s2){
                            System.out.println(Thread.currentThread().getName() + " : 获取"+s2+"开吃！");
                        }
                    }
                }
            }
        },"汤辉").start();

        new Thread("徐玲"){
            @Override
            public void run() {
                while ( true ){
                    synchronized (s2){
                        System.out.println(this.getName() + " : 获取"+s2+"等待"+s1);
                        synchronized (s1){
                            System.out.println(this.getName() + " : 获取" + s1 + "开吃");
                        }
                    }
                }
            }
        }.start();

    }
}