Java多线程和锁

一.Java多线程

多线程是指程序中可以执行多个线程，每一个线程完成一个功能，并且是多个线程一起执行。

package com.hly.java.MyThread;

/**
 * @author :hly
 * @date :2018/5/31
 */
public class MyThread extends Thread {
    
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.print(Thread.currentThread().getName() + ":" + i + " ");
            try {
                if (i == 3)
                    //线程停止中断

                    Thread.interrupted();
                //线程睡眠3秒
                Thread.sleep(2000);


            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] arv) {
        System.out.println("Java多线程分析:");
        //实例化类对象
        MyThread myThread = new MyThread();
        //该类对象实例化的线程,第二个参数为线程的名字
        Thread t1 = new Thread(myThread, "t1");
        Thread t2 = new Thread(myThread, "t2");
        Thread t3 = new Thread(myThread, "t3");

        try {
            //t1线程开始
            t1.start();
            //线程等待状态，比如说远程资源你们有传到客户端时，你可以等线程等待一下
            //t1.wait();
            //线程取消等待状态
            //t1.notify();
            //join表示当前线程完成后下一线程才能开始
            t1.join();
            //t2线程开始
            t2.start();
            t3.start();
            //设置线程的优先级，等级分为1-10,t3总会在t2前面先运行
            t2.setPriority(9);
            t3.setPriority(10);
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

二.线程安全

比如售票系统，多个人同时买多张票就会出现问题，所以我们需要线程同步机制synchronized

2.1.Synchronized的用法

可以用在任何类的方法里面，即使没有实现线程类

1.Synchronized(this)

当前同步块所在方法所在的类，不需要引用别的类时

锁住代码块的当前对象，等访问该对象的线程执行完毕，其他线程才能执行

2.Synchronized(x.class)

锁住该类，所有访问该类的工程，一次只有一个可以执行，比如Mybatis的sqlSessionFactory..

如果它作用的对象是非静态的，那他锁的是对象，如果他作用的对象是静态方法或者是类，对类的所有对象实例起作用，也就是用同一把锁。

下面是Mybatis的实现代码：

public static SqlSessionFactory getSqlSessionFactory() {
        //防止在多线程中多次实例化SqlsessionFactory，保证其唯一性
        synchronized (LOCK){
            //不为空，说明已经被创建，直接返回
            if(sqlSessionFactory!=null){
                return sqlSessionFactory;
            }
            String resource = "mybatis-config.xml";
            InputStream inputStream;
            try {
                inputStream = Resources.getResourceAsStream(resource);
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }
            return sqlSessionFactory;
        }
    }

3.下面是Synchronized同步机制代码

语法为：

Synchronized（Object）{
}

共享资源放在该区域内，其他线程获得这个锁时，必须等待锁释放才能进入该区域，Object为一个对象，每一对象有一个标志为0和1，线程运行到同步块检查标志，为0，表示其他线程在运行，同步快中代码被执行完则为1，该线程才能执行该块中的代码，并将Object标识设置为0，防止其他线程运行。

package com.hly.java.MyThread;

/**
 * @author :hly
 * @date :2018/5/31
 */
public class ThreadSafe extends Thread {
    int i =10;
    public void run(){
        while (true){
            synchronized (this){
                if(i>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+i--);
                }
            }
        }
    }

    public static void main(String[]arv){
        ThreadSafe threadSafe = new ThreadSafe();
        Thread t1 = new Thread(threadSafe,"t1");
        Thread t2 = new Thread(threadSafe,"t2");
        Thread t3 = new Thread(threadSafe,"t3");
        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized同步方法，同上，必须等该方法执行完毕其他线程才能执行，运行结果和同步快结果一致。

package com.hly.java.MyThread;

/**
 * @author :hly
 * @date :2018/5/31
 */
public class ThreadSafe extends Thread {
    int i =10;

    synchronized void mySynchronized(){
        if(i>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i--);
        }
    }
    public void run(){
       while(true){
           mySynchronized();
       }
    }

    public static void main(String[]arv){
        ThreadSafe threadSafe = new ThreadSafe();
        Thread t1 = new Thread(threadSafe,"t1");
        Thread t2 = new Thread(threadSafe,"t2");
        Thread t3 = new Thread(threadSafe,"t3");
        t1.start();
        t2.start();
        t3.start();
    }
}

没加Synchronized情况

反之：

文章持续更新中。。。。。。。

猜你喜欢