java多线程

实现多线程的三种方式

1）一种是继承 Thread 类，
2）是实现 Runable 接口，
3）实现 Callable 接口，并与 Future、线程池结合使用（Runnable 和 Callable 都代表那些要在不同的线程中执行的任务。Runnable 从 JDK1.0 开始就有了，Callable 是在 JDK1.5 增加的。它们的主要区别是 Callable 的 call( ) 方法可以返回值和抛出异常，而 Runnable 的 run() 方法没有这些功能。Callable 可以返回装载有计算结果的 Future 对象。

实现 Runnable 接口比继承 Thread 类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免 java 中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
4）：线程池只能放入实现 Runable 或 callable 类线程，不能直接放入继承 Thread 的类

线程的状态：新建状态、就绪状态、运行状态、阻塞状态及死亡状态

\1. 新建 (new)：新创建了一个线程对象。

\2. 可运行 (runnable)：线程对象创建后，其他线程 (比如 main 线程）调用了该对象的 start () 方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 cpu 的使用权。

\3. 运行 (running)：可运行状态 (runnable) 的线程获得了 cpu 时间片（ timeslice ），执行程序代码。

\4. 阻塞 (block)：阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice ，暂时停止运行。直到线程进入可运行 (runnable) 状态，才有机会再次获得 cpu timeslice 转到运行 ( running ) 状态。阻塞的情况分三种：

(一). 等待阻塞：运行 (running) 的线程执行 o . wait () 方法， JVM 会把该线程放入等待队列 (waitting queue) 中。

(二). 同步阻塞：运行 (running) 的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池 ( lock pool ) 中。

(三). 其他阻塞: 运行 (running) 的线程执行 Thread . sleep (long ms) 或 t . join () 方法，或者发出了 I / O 请求时， JVM 会把该线程置为阻塞状态。当 sleep ()状态超时、 join ()等待线程终止或者超时、或者 I / O 处理完毕时，线程重新转入可运行 ( runnable ) 状态。

5. 死亡 (dead)：线程 run ()、 main () 方法执行结束，或者因异常退出了 run () 方法，则该线程结束生命周期。死亡的线程不可再次复生。

java 多线程同步

为何要使用同步？

java 允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。

一、同步方法

　　即有 synchronized 关键字修饰的方法。由于 java 的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

注： synchronized 关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

public synchronized void save(){}

二、同步代码块

　　即有 synchronized 关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

synchronized(object){ }

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用 synchronized 代码块同步关键代码即可。

public class SynchronizedThread {
    class Bank {
        private int account = 100;
        public int getAccount() {
            return account;
        }
         用同步方法实现
        public synchronized void save(int money) {
            account += money;
        }
         用同步代码块实现
        public void save1(int money) {
            synchronized (this) {
                account += money;
            }
        }
    }
    class NewThread implements Runnable {
        private Bank bank;
        public NewThread(Bank bank) {
            this.bank = bank;
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                // bank.save1(10);
                bank.save(10);
                System.out.println(i + "账户余额为：" + bank.getAccount());
            }
        }
    }
    建立线程，调用内部类
    public void useThread() {
        Bank bank = new Bank();
        NewThread new_thread = new NewThread(bank);
        System.out.println("线程1");
        Thread thread1 = new Thread(new_thread);
        thread1.start();
        System.out.println("线程2");
        Thread thread2 = new Thread(new_thread);
        thread2.start();
    }
    public static void main(String[] args) {
        SynchronizedThread st = new SynchronizedThread();
        st.useThread();
    }

三、使用特殊域变量 (volatile) 实现线程同步

a.volatile 关键字为域变量的访问提供了一种免锁机制
b. 使用 volatile 修饰域相当于告诉虚拟机该域可能会被其他线程更新
c. 因此每次使用该域就要重新计算，而不是使用寄存器中的值
d.volatile 不会提供任何原子操作，它也不能用来修饰 final 类型的变量

只给出要修改的代码，其余代码与上同
    class Bank {
        需要同步的变量加上volatile
        private volatile int account = 100;
        public int getAccount() {
            return account;
        }
       这里不再需要synchronized 
        public void save(int money) {
            account += money;
        }
    ｝

注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。用 final 域，有锁保护的域和 volatile 域可以避免非同步的问题。

四、使用重入锁实现线程同步

在 JavaSE5.0 中新增了一个 java.util.concurrent 包来支持同步。 ReentrantLock 类是可重入、互斥、实现了 Lock 接口的锁，它与使用 synchronized 方法和块具有相同的基本行为和语义，并且扩展了其能力 ReenreantLock 类的常用方法有： ReentrantLock() : 创建一个 ReentrantLock 实例 lock() : 获得锁 unlock() : 释放锁注：ReentrantLock() 还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用

private int account = 100;
       需要声明这个锁
        private Lock lock = new ReentrantLock();
        public int getAccount() {
            return account;
        }
       这里不再需要synchronized 
        public void save(int money) {
            lock.lock();
            try{
                account += money;
            }finally{
                lock.unlock();
            }
        }
    ｝

注：关于 Lock 对象和 synchronized 关键字的选择：

a. 最好两个都不用，使用一种 java.util.concurrent 包提供的机制，能够帮助用户处理所有与锁相关的代码。

b. 如果 synchronized 关键字能满足用户的需求，就用 synchronized，因为它能简化代码

c. 如果需要更高级的功能，就用 ReentrantLock 类，此时要注意及时释放锁，否则会出现死锁，通常在 finally 代码释放锁

五、使用局部变量实现线程同步

如果使用 ThreadLocal 管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

------ThreadLocal类的常用方法 
ThreadLocal() : 创建一个线程本地变量 
get() : 返回此线程局部变量的当前线程副本中的值 
initialValue() : 返回此线程局部变量的当前线程的"初始值" 
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
只改Bank类，其余代码与上同 
public class Bank{ 
  使用ThreadLocal类管理共享变量account 
    private static ThreadLocal account = new ThreadLocal(){ 
        @Override 
        protected Integer initialValue(){ 
        return 100; 
        } 
    }; 
    public void save(int money){ 
        account.set(account.get()+money); 
    } 
    public int getAccount(){ 
        return account.get(); 
    } 
}

注：ThreadLocal 与同步机制

a.ThreadLocal 与同步机制都是为了解决多线程中相同变量的访问冲突问题。

b. 前者采用以 "空间换时间" 的方法，后者采用以 "时间换空间" 的方式

Java 多线程中的死锁

死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。这是一个严重的问题，因为死锁会让你的程序挂起无法完成任务，死锁的发生必须满足以下四个条件：

- 互斥条件：一个资源每次只能被一个进程使用。
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
- 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁最简单的方法就是阻止循环等待条件，将系统中所有的资源设置标志位、排序，规定所有的进程申请资源必须以一定的顺序（升序或降序）做操作来避免死锁。

Java 多线程中调用 wait() 和 sleep() 方法有什么不同？

Java 程序中 wait 和 sleep 都会造成某种形式的暂停，它们可以满足不同的需要。wait() 方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而 sleep() 方法仅仅释放 CPU 资源或者让当前线程停止执行一段时间，但不会释放锁。需要注意的是，sleep（）并不会让线程终止，一旦从休眠中唤醒线程，线程的状态将会被改变为 Runnable，并且根据线程调度，它将得到执行。

线程之间是如何通信的？

当线程间是可以共享资源时，线程间通信是协调它们的重要的手段。Object 类中 wait()\notify()\notifyAll() 方法可以用于线程间通信

wait()-------- 该方法用来将当前线程置入休眠状态，直到接到通知或被中断为止。在调用 wait() 之前，线程必须要获得该对象的对象级别锁，即只能在同步方法或同步块中调用 wait() 方法。进入 wait() 方法后，当前线程释放锁。

notify()-------- 该方法也要在同步方法或同步块中调用，即在调用前，线程也必须要获得该对象的对象级别锁。
该方法用来通知那些可能等待该对象的对象锁的其他线程。如果有多个线程等待，则线程规划器任意挑选出其中一个 wait() 状态的线程来发出通知，并使它等待获取该对象的对象锁（notify 后，当前线程不会马上释放该对象锁，wait 所在的线程并不能马上获取该对象锁，要等到程序退出 synchronized 代码块后，当前线程才会释放锁，wait 所在的线程也才可以获取该对象锁），但不惊动其他同样在等待被该对象 notify 的线程们

notifyAll()----------- 使所有原来在该对象上 wait 的线程统统退出 wait 的状态，即全部被唤醒，一旦该对象锁被释放（notifyAll 线程退出调用了 notifyAll 的 synchronized 代码块的时候），他们就会去竞争。如果其中一个线程获得了该对象锁，它就会继续往下执行，在它退出 synchronized 代码块，释放锁后，其他的已经被唤醒的线程将会继续竞争获取该锁，一直进行下去，直到所有被唤醒的线程都执行完毕。

如何确保线程安全？

线程同步是最简单和常用的方法来确保线程安全

通过使用 java.util.concurrent.atomic 包中的原子类，可以确保操作的原子性
通过使用 java.util.concurrent.locks 包中的锁可以确保线程安全
使用线程安全的并发集合，比如 ConcurrentHashMap 来确保线程安全
通过 volatile 关键字来确保每次的变量使用都从内存中访问数据，而非访问线程缓存
多线程并发情况下，线程共享的变量改为方法局部级变量

posted @ 2020-03-02 12:01 别再闹了阅读(172) 评论(0) 收藏举报

刷新页面返回顶部

别再闹了

某C9高校计算机在读研究生，现在主要研究计算机视觉，之前研究过Java
background:《June Sunshine》，Alfred Sisley
写博客是为了构建知识系统，有原创也有转载

java多线程

java多线程

实现多线程的三种方式

实现 Runnable 接口比继承 Thread 类所具有的优势：

线程的状态：新建状态、就绪状态、运行状态、阻塞状态及死亡状态

java 多线程同步

为何要使用同步？

一、同步方法

二、同步代码块

三、使用特殊域变量 (volatile) 实现线程同步

四、使用重入锁实现线程同步

五、使用局部变量实现线程同步

Java 多线程中的死锁

Java 多线程中调用 wait() 和 sleep() 方法有什么不同？

线程之间是如何通信的？

如何确保线程安全？

公告

别再闹了

某C9高校计算机在读研究生，现在主要研究计算机视觉，之前研究过Javabackground:《June Sunshine》，Alfred Sisley 写博客是为了构建知识系统，有原创也有转载

java多线程

java多线程

实现多线程的三种方式

实现 Runnable 接口比继承 Thread 类所具有的优势：

线程的状态：新建状态、就绪状态、运行状态、阻塞状态及死亡状态

java 多线程同步

为何要使用同步？

一、同步方法

*二、同步代码块*

三、使用特殊域变量 (volatile) 实现线程同步

四、使用重入锁实现线程同步

五、使用局部变量实现线程同步

Java 多线程中的死锁

Java 多线程中调用 wait() 和 sleep() 方法有什么不同？

线程之间是如何通信的？

如何确保线程安全？

公告

某C9高校计算机在读研究生，现在主要研究计算机视觉，之前研究过Java
background:《June Sunshine》，Alfred Sisley
写博客是为了构建知识系统，有原创也有转载

二、同步代码块