java多线程

最新推荐文章于 2024-03-20 10:15:00 发布

叶赫那拉.卡夫卡

最新推荐文章于 2024-03-20 10:15:00 发布

阅读量106

点赞数

分类专栏： java

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章参考https://www.cnblogs.com/ganchuanpu/p/7704468.html

创建新执行线程第一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。例如，计算大于某一规定值的质数的线程可以写成：

     class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

然后，下列代码会创建并启动一个线程：

     PrimeThread p = new PrimeThread(143);
     p.start();

创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。采用这种风格的同一个例子如下所示：

     class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

然后，下列代码会创建并启动一个线程：

     PrimeRun p = new PrimeRun(143);
     new Thread(p).start();

每个线程都有一个标识名，多个线程可以同名。如果线程创建时没有指定标识名，就会为其生成一个新名称。

使用Callable和Future接口创建线程

具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

看着好像有点复杂，直接来看一个例子就清晰了。

public class ThreadTest {

    public static void main(String[] args) {

        Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                thread.start();                      //线程进入到就绪状态
            }
        }

        System.out.println("主线程for循环执行完毕..");
        
        try {
            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}


class MyCallable implements Callable<Integer> {
    private int i = 0;

    // 与run()方法不同的是，call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }

}

首先，我们发现，在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。那么看下FutureTask类的定义：

public class FutureTask<V> implements RunnableFuture<V> {
     
    //....
    
}


public interface RunnableFuture<V> extends Runnable, Future<V> {
    
   void run();
   
}

于是，我们发现FutureTask类实际上是同时实现了Runnable和Future接口，由此才使得其具有Future和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，使得其可以取得新创建线程中的call()方法的返回值。

执行下此程序，我们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕..”则很可能是在子线程循环中间输出。由CPU的线程调度机制，我们知道，“主线程for循环执行完毕..”的输出时机是没有任何问题的，那么为什么sum =4950会永远最后输出呢？

原因在于通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。

上述主要讲解了三种常见的线程创建方式，对于线程的启动而言，都是调用线程对象的start()方法，需要特别注意的是：不能对同一线程对象两次调用start()方法。

线程同步：

同步的方式

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

代码如： 
public synchronized void save(){}

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

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

代码如： 
synchronized(object){ 
}


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

package com.xhj.thread;

    /**
     * 线程同步的运用
     * 
     * @author XIEHEJUN
     * 
     */
    public class SynchronizedThread {

        class Bank {

            private int account = 100;

            public int getAccount() {
                return account;
            }

            /**
             * 用同步方法实现
             * 
             * @param money
             */
            public synchronized void save(int money) {
                account += money;
            }

            /**
             * 用同步代码块实现
             * 
             * @param 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();
        }

    }

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

例如：
在上面的例子当中，只需在account前面加上volatile修饰，即可实现线程同步。

  class Bank {
            //需要同步的变量加上volatile
            private volatile int account = 100;

            public int getAccount() {
                return account;
            }
            //这里不再需要synchronized 
            public void save(int money) {
                account += money;
            }
        ｝

多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。

volatile使用意义：
Java内存模型：
从下面图中可以看出，java的内存模型定义了主内存和本地内存，这是一种抽象的概念。主内存是所有线程可以共享的区域，本地内存为线程私有化。为了提高性能，线程通常不直接从主内存中读出和写入内容，而是通过本地内存，并通过一定的刷新机制进行内容同步。本文主要介绍volatile相关知识，关于java内存模型内容在后面专题分析。以下分别为不使用volatile和使用volatile关键字的区别：

volatile意义：
上图看出，当线程A与线程B访问同一个变量a时，若在线程A中将a的值从0修改为1，线程B中读取变量a的值，依然是0。而使用volatile关键字之后情况就不一样，线程B读取到a的值为1。原因在与，没有使用volatile关键字修饰变量时，线程A的修改只是在本地内存A中，不会同步到主内存，线程B也只是从本地内存B中读取，因此无法实现修改同步。使用volatile关键字之后，在线程A中修改了a的值，会将修改从本地内存A写入到主内存中，而当线程B读取a的值时，会直接从主内存中读取，并刷新本地内存B。因此，线程A与线程B便能够实现内存之间的共享了，实现内存的可见性。

volatile实现原理：
被修饰变量值修改时处理器会将缓存行数据写入到主内存中
如果变量被声明为volatile，当进行写操作时，JVM会向处理器发送一条Lock前缀的指令，然后将变量在缓存中所修改的值写入到系统内存中。

缓存一致性协议
如果volatile仅仅只有将缓存数据写入到系统主存的能力，并不能实现线程之间的共享。当有多个处理器存在的情况下，为了保证各个处理器缓存内容的一致性，处理器会实现缓存一致性协议。每个处理器通过嗅探在总线上传播的数据，检查自己缓存的值是不是过期，当处理器发现自己缓存中所对应变量的内存地址被修改时，就会将当前缓存行标志成无效状态，当处理器需要读取或是修改数据时，会直接从主内存中加载数据到缓存中，保证数据的一致性。

volatile 是保证数据被改动后所有线程都能及时得到最新的值，但至于这个数据有没有被改对这个 volatile 没法保证。例如 volatile int i = 0; 假如此时多个线程对 i 进行赋值修改，而且是特别简单的赋值语句没有任何其他运算操作，如 i = 0 或 i = 1 或 i = a （a 也是一个 int 变量）之类的简单赋值，因为这种简单的赋值具有原子性，一条指令就能完成，所以在赋值的过程中不会被其他线程抢断，所以每个线程都总能正确地赋值成功，这时候在 i 被赋值修改之后其他线程会立即得到 i 的新值，如果没有 volatile ，其他线程不一定能及时知道 i 的新值，因为存在一定的寄存器缓存干扰。这样看起来 volatile 貌似是线程安全的，但这个安全是由简单赋值语句的原子性保证的，即没办法两个线程同时对 i 进行赋值，所以 i 安全，而 volatile 只保证新值的及时共享可见。假如 i 不是进行简单赋值操作，而是 i++ 操作，因为 i++ 需要多条指令，没有原子性，一个线程在操作的过程中可以被其他线程抢断，所以 i 的值就会发生错乱，但是 i 就算是被修改成错误的值，但 volatile 也会及时保证这个错误的值在所有线程中共享可见，这时看起来 volatile 就无法保证线程安全了

只是概括性介绍volatile的一些基础知识，对于原理的分析比较简单易懂。如果要深入了解可以读以下《java并发编程的艺术》一书，书中有比较详细的知识，或是参考这篇文章 https://www.ibm.com/developerworks/cn/java/j-jtp06197.html

ThreadLocal https://www.cnblogs.com/dolphin0520/p/3920407.html

叶赫那拉.卡夫卡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java多线程

文章参考https://www.cnblogs.com/ganchuanpu/p/7704468.html创建新执行线程第一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。例如，计算大于某一规定值的质数的线程可以写成： class PrimeThread extends Thread { ...
复制链接

扫一扫