Rtia
Rtia

JAVA 线程

【JAVA 线程】

线程

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。（如迅雷多线程下载）

Java VM启动的时候会有一个进程java.exe.
该进程中至少一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。

扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。（主线程在执行其它对象时，无用对象在被垃圾回收）
 多线程存在的意义。（一个线程执行过程中产生垃圾，另一个在回收垃圾）
 线程的创建方式
 多线程的特性

程序 VS 进程 VS 线程

程序 VS 进程

程序: 一段静态的代码，一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体，是应用软件执行的蓝本。

进程: 是程序的一次动态执行，它对应着从代码加载，执行至执行完毕的一个完整的过程，是一个动态的实体，它有自己的生命周期。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。反映了一个程序在一定的数据 集上运行的全部动态过程。通过进程控制块(PCB)唯一的标识某个进程。同时进程占据着相应的资源（例如包括cpu的使用 ，轮转时间以及一些其它设备的权限）。是系统进行资源分配和调度的一个独立单位。

程序和进程之间的主要区别：

\ 状态 是否具有资源 是否有唯一标识 是否具有并发性
程序 静态 无 无 无
进程 动态 有 有 有

进程的基本状态:

1、就绪（Ready）状态
当进程已分配到除CPU以外的所有必要资源后，只要再获得CPU，便可立即执行，进程这时的状态就称为就绪状态。在一个系统中处于就绪状态的进程可能有多个，通常将他们排成一个队列，称为就绪队列。

2、执行状态
进程已获得CPU，其程序正在执行。在单处理机系统中，只有一个进程处于执行状态；再多处理机系统中，则有多个进程处于执行状态。

3、阻塞状态
正在执行的进程由于发生某事件而暂时无法继续执行时，便放弃处理机而处于暂停状态，亦即程序的执行受到阻塞，把这种暂停状态称为阻塞状态，有时也称为等待状态或封锁状态。

三种进程之间的转换图：

JAVA 线程_第1张图片

线程

线程: 可以理解为进程的多条执行线索，每条线索又对应着各自独立的生命周期。线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

Java中的线程要经历4个过程

  1. 创建
    创建一个Java线程常见的有两种方式:
    继承Thread类和实现Runnable接口这两种方式。

  2. 执行
    线程创建后仅仅占有了内存资源，在JVM管理的线程中还没有该线程，该线程必须调用start方法通知JVM，这样JVM就会知道又有一个新的线程排队等候了。如果当前线程轮到了CPU的使用权限的话，当前线程就会继续执行。

  3. 中断
    a. JVM将CPU的使用权限从当前线程切换到其它线程，使本线程让出CPU的使用权限而处于中断状态。
    b. 线程在执行过程中调用了sleep方法，使当前线程处于休眠状态。
    c. 线程在执行的过程中调用wait方法
    d. 线程在使用cpu资源期间，执行了某个操作而进如阻塞状态。

  4. 死亡
    死亡的线程不在具有执行能力。线程死亡的原因有二：
    a. 线程正常运行结束而引起的死亡，即run方法执行完毕。
    b. 线程被提前强制终止。

线程的创建方式

通过对api的查找，java已经提供了对线程这类事物的描述，即Thread类。

创建线程方式一：继承Thread类

  1. 定义类继承Thread
  2. 子类覆盖父类Thread中的run方法。
    目的：将自定义线程运行的代码存储在run方法。
  3. 建立子类对象的同时线程也被创建。
  4. 调用线程的start方法。
    该方法两个作用：启动线程，调用run方法。通过调用start方法开启线程。
Demo d = new Demo();//创建好一个线程。
d.start();//开启线程并执行该线程的run方法。
// d.run();//仅仅是对象调用方法。而线程创建了，并没有运行。

每次运行结果都不同：
因为多个线程都在获取cpu的执行权。cpu执行到谁，谁就运行。明确一点，在某一个时刻，只能有一个程序在运行。(多核除外)

cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象把多线程的运行形容为互相抢夺cpu的执行权（资源）。
这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说的算。

为什么要覆盖run方法：
Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程要运行的代码。

线程都有自己默认名称：Thread-编号（该编号从0开始）
　　　　　getName(): 获取线程名称。
设置线程名称：setName或者构造函数。

static Thread.currentThread():获取当前线程对象。

习题：创建两个线程，和主线程交替运行

public class Test extends Thread {
    //private String name;
    Test(String name) {
        super(name); //this.name = name;
    }

    public void run() {
        for (int x = 0; x < 60; x++) {
            System.out.println((Thread.currentThread() == this) + "..." + this.getName() + " run..." + x); //当前运行线程即为调用对象线程
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        Test t1 = new Test("one---");
        Test t2 = new Test("two+++");
        t1.start();//开启线程并执行该线程的run方法。
        t2.start();
        for (int x = 0; x < 60; x++) {
            System.out.println("main....." + x);
        }
    }
}

线程的四种状态

[图片上传失败...(image-40f7cc-1516803892359)]
sleep方法需要指定睡眠时间，单位是毫秒。

创建线程方式二：实现Runnable接口

  1. 定义类实现Runnable接口
  2. 覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。
  3. 通过Thread类创建线程
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
    因为，自定义的run方法所属的对象是Runnable接口的子类对象。
    所以要让线程去指定指定对象的run方法，就必须明确该run方法所属对象。

public Thread(Runnable target)
分配新的 Thread 对象。这种构造方法与 Thread(null, target, gname ) 具有相同的作用，其中的 gname 是一个新生成的名称。自动生成的名称的形式为 “Thread-”+ n，其中的 n 为整数。
参数：target - 其 run 方法被调用的对象。
另请参见：[Thread(ThreadGroup, Runnable, String)](http://tool.oschina.net/uploads/apidocs/jdk-zh/java/lang/Thread.html#Thread(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String))

  1. 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

实现方式VS继承方式：

实现方式好处：避免单继承的局限性。在定义线程时，建议使用实现方式。

两种方式区别：
继承Thread：线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法。

线程安全问题

运行发现，可能会打印出0，-1，-2等错票。多线程的运行出现了安全问题。
原因：
　　多个线程访问出现延迟。
　　 线程随机性。
　　(当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。)
注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式，即同步代码块。（synchronized）

同步（synchronized）

格式：

synchronized(对象) {
    需要被同步的代码 //运行到共享数据的代码
}

同步可以解决安全问题的根本原因就在那个对象上，该对象如同锁的功能。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权也进不去，因为没有获取锁。（eg.火车上的卫生间-有人就锁门，其它人进不来）

同步的特点

同步的前提：
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。
未满足这两个条件，不能称其为同步。
必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题
弊端：多个线程需要判断锁，较为消耗资源（当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。）

习题：简单的卖票程序，多个窗口同时买票。

public class Ticket implements Runnable//extends Thread
{
    private int tick = 100;
    Object obj = new Object();//通过Object创建锁对象

    public void run() {
        while (true) {
            synchronized (obj) {//同步，防止线程安全问题
                if (tick > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                    }
                    //在没Synchronized的情况下用sleep方法人为让线程停在这儿，验证是否会像下面这样出现安全问题
                    //如没Synchronized，可能在tick=1时，多个线程判断完停在这儿，再轮到它们运行时导致共享数据tick运行结果出现负数（tick=1 tick=0 tick=-1…），即出现线程安全问题
                    System.out.println(Thread.currentThread().getName() + "....sale : " + tick--);
                }
            }
        }
    }
}

public class TicketDemo {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        Thread t1 = new Thread(t);//创建了一个线程；运行Ticket t里面的run方法
        Thread t2 = new Thread(t);//创建了一个线程；
        Thread t3 = new Thread(t);//创建了一个线程；
        Thread t4 = new Thread(t);//创建了一个线程；
        Thread t5 = new Thread(t);//创建了一个线程；
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        
        //如用下面方法1 extends Thread，四个窗口各卖100张票共400张票，比总票数100张多，不合理；故用上面方法2 implements Runnable
        /*
        Ticket t1 = new Ticket();
        //Ticket t2 = new Ticket();
        //Ticket t3 = new Ticket();
        //Ticket t4 = new Ticket();
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        */
    }
}

同步函数

格式： 在函数上加上synchronized修饰符即可。

同步函数用的是哪一个锁：

  1. 函数需要被对象调用。那么函数都有一个所属对象引用，就是this，所以同步函数使用的锁是this。
  2. 静态的同步方法，使用的锁是该方法所在类的字节码文件对象：
    类名.class
    因为静态方法中不可以定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class

如何找线程安全问题：
1，明确哪些代码是多线程运行代码。
2，明确共享数据。
3，明确多线程运行代码中哪些语句是操作共享数据的。

习题：银行存储

有两个储户分别存300元，每次存100，存3次。
目的：该程序是否有安全问题，如果有，如何解决？

public class Bank {
    private int sum;

    public synchronized void add(int n) {
        sum = sum + n;
        try {
            Thread.sleep(10);
        } catch (Exception e) {
        }
        System.out.println("sum=" + sum);
    }
}

public class Cus implements Runnable {
    private Bank b = new Bank();

    public void run() {
        for (int x = 0; x < 3; x++) {
            b.add(100);
        }
    }
}

public class BankDemo {
    public static void main(String[] args) {
        Cus c = new Cus();
        new Thread(c).start();
        new Thread(c).start();
    }
}

死锁

同步中嵌套同步，用到不同的锁。

习题：写一个死锁程序

public class Test implements Runnable {
    private boolean flag;

    Test(boolean flag) {
        this.flag = flag;
    }

    public void run() {
        if (flag) {
            while (true) {
                synchronized (MyLock.locka) {
                    System.out.println(Thread.currentThread().getName() + "...if locka ");
                    synchronized (MyLock.lockb) {
                        System.out.println(Thread.currentThread().getName() + "..if lockb");
                    }
                }
            }
        } else {
            while (true) {
                synchronized (MyLock.lockb) {
                    System.out.println(Thread.currentThread().getName() + "..else lockb");
                    synchronized (MyLock.locka) {
                        System.out.println(Thread.currentThread().getName() + ".....else locka");
                    }
                }
            }
        }
    }
}

class MyLock {
    static Object locka = new Object();
    static Object lockb = new Object();
}

class DeadLockTest {
    public static void main(String[] args) {
        /*      Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test(false));
                t1.start();
                t2.start();  */
        new Thread(new Test(true)).start();//匿名对象，对上面简化
        new Thread(new Test(false)).start();
    }
}

线程间通信

[图片上传失败...(image-faf4a5-1516803892359)]

线程间通讯：
其实就是多个线程在操作同一个资源，但是操作的动作不同。

wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中？

  1. wait(),notify(),notifyAll()方法都使用在同步中，因为这些方法要对持有监视器(锁)的线程操作（而只有同步才具有锁）
  2. 使用这些方法时必须要标识所属的同步的锁。（因为这些方法在操作同步中线程时，都必须要标识它们所操作线程共有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。）
  3. 锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

wait(),sleep()的区别：
wait():释放cpu执行权，释放锁。
sleep():释放cpu执行权，不释放锁。

习题：交替输入输出姓名性别（2线程）

public class Res {
    private String name;
    private String sex;
    private boolean flag = false;

    public synchronized void set(String name, String sex) {
        if (flag)
            try {
                this.wait(); //wait等待把线程放到线程池里
            } catch (Exception e) {
            }
        this.name = name;
        this.sex = sex;
        System.out.println("【SET】" + name + sex);
        flag = true;
        this.notify();//notify唤醒一个，一般最先唤醒最早wait进线程池的
                        //notifyAll();唤醒全部
    }

    public synchronized void out() {
        if (!flag)
            try {
                this.wait();
            } catch (Exception e) {
            }
        System.out.println("【OUT】" + name + sex);
        flag = false;
        this.notify();
    }
}

class Input implements Runnable {
    private Res r;

    Input(Res r) {
        this.r = r;
    }

    public void run() {
        int x = 1;
        while (x < 6) {
            r.set("丽丽" + x, "女");
            x++;
        }
    }
}

class Output implements Runnable {
    private Res r;

    Output(Res r) {
        this.r = r;
    }

    public void run() {
        while (true) {
            r.out();
        }
    }
}

public class InputOutputDemo2 {
    public static void main(String[] args) {
        Res r = new Res();
        new Thread(new Input(r)).start();
        //用匿名对象简化代码，因为只调用该对象的一个方法--start方法--一次
        new Thread(new Output(r)).start();
        /*
        Input in = new Input(r);
        Output out = new Output(r);
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();
        */
    }
}

结果：

【SET】丽丽1女
【OUT】丽丽1女
【SET】丽丽2女
【OUT】丽丽2女
【SET】丽丽3女
【OUT】丽丽3女
【SET】丽丽4女
【OUT】丽丽4女
【SET】丽丽5女
【OUT】丽丽5女

习题：交替生产消费商品（多线程，为商品编号）

对于多个生产者和消费者，为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll：需要唤醒对方线程。只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

public class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r = new Resource();
        new Thread(new Producer(r)).start();
        new Thread(new Producer(r)).start();
        new Thread(new Consumer(r)).start();
        new Thread(new Consumer(r)).start();
    }
}

class Resource {
    private String name;
    private int count = 1; //为商品编号
    private boolean flag = false;

    //  t1    t2
    public synchronized void set(String name) {
        while (flag) {
            //如果用if，线程判断完如停在这儿等再被唤醒就不再判断直接向下运行
            try {
                this.wait();
            } catch (Exception e) {
            } //t1(放弃资格)  t2(获取资格)
        }
        this.name = name + "--" + count++;
        System.out.println(Thread.currentThread().getName() + "...生产者.." + this.name);
        flag = true;
        this.notifyAll();
    }

    //  t3   t4  
    public synchronized void out() {
        while (!flag) {
            try {
                wait();
            } catch (Exception e) {
            } //t3(放弃资格) t4(放弃资格)
        }
        System.out.println(Thread.currentThread().getName() + "...消费者........." + this.name);
        flag = false;
        this.notifyAll();
    }
}

class Producer implements Runnable {
    private Resource res;

    Producer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.set("+商品+");
        }
    }
}

class Consumer implements Runnable {
    private Resource res;

    Consumer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.out();
        }
    }
}

[图片上传失败...(image-2b4d4f-1516803892359)]

多线程升级解决方案

JDK1.5 中提供了多线程升级解决方案：

将同步Synchronized替换成显式Lock操作。

将Object中的wait，notify, notifyAll，替换成Condition对象。该对象可以通过Lock锁进行获取。

Lock 实现提供了比使用 synchronized方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的Condition 对象。

Lock:替代了Synchronized
　　　lock
　　　unlock
　　　newCondition()

Condition：替代了Object wait notify notifyAll
　　　await();
　　　signal();
　　　signalAll();

习题：交替生产消费（用Lock，实现本方只唤醒对方操作）

public class ProducerConsumerDemo2 {
    public static void main(String[] args) {
        Resource2 r = new Resource2();
        new Thread(new Producer2(r)).start();
        new Thread(new Producer2(r)).start();
        new Thread(new Consumer2(r)).start();
        new Thread(new Consumer2(r)).start();
    }

}

class Resource2 {
    private String name;
    private int count = 1;
    private boolean flag = false;
    //  t1    t2
    private Lock lock = new ReentrantLock();
    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();

    //Lock可以支持多个相关的 Condition 对象
    public void set(String name) throws InterruptedException {
        lock.lock();
        try {
            while (flag)
                condition_pro.await();//t1,t2
            this.name = name + "--" + count++;
            System.out.println(Thread.currentThread().getName() + "...生产者.." + this.name);
            flag = true;
            condition_con.signal();//唤醒对应等待线程
        } finally {
            lock.unlock();//释放锁的动作一定要执行。
        }
    }

    //  t3   t4  
    public void out() throws InterruptedException {
        lock.lock();
        try {
            while (!flag)
                condition_con.await();
            System.out.println(Thread.currentThread().getName() + "...消费者........." + this.name);
            flag = false;
            condition_pro.signal();
        } finally {
            lock.unlock();
        }
    }
}

class Producer2 implements Runnable {
    private Resource2 res;

    Producer2(Resource2 res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            try {
                res.set("+商品+");
            } catch (InterruptedException e) {
            }
        }
    }
}

class Consumer2 implements Runnable {
    private Resource2 res;

    Consumer2(Resource2 res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            try {
                res.out();
            } catch (InterruptedException e) {
            }
        }
    }
}

停止线程

  1. 定义循环结束标记
    因为线程运行代码一般都是循环，只要控制了循环即可，让run方法结束，也就是线程结束。
  2. 使用interrupt（中断）方法。
    该方法是结束线程的冻结状态，使线程回到运行状态中来。（当线程处于冻结状态，就不会读取到标记，那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。）

注：stop方法已经过时不再使用。
(有bug不再使用，但老程序里面有stop所以没取消)

习题：停止线程（分别用循环结束标记、interrupt、setDaemon）

public class StopThreadDemo {
    public static void main(String[] args) {
        StopThread st = new StopThread();
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        
        //守护线程，其所守护的线程结束，它本身也结束（main结束了，即使t1、t2还在wait，也随main结束而结束）
        t1.setDaemon(true);
        t2.setDaemon(true);
        
        t1.start();
        t2.start();
        int num = 0;
        while (true) {
            if (num++ == 60) {
                st.changeFlag();//num自增到60执行循环结束标记
                t1.interrupt();//对冻结进行清除
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName() + "......." + num);
        }
        System.out.println("over");
    }

}

class StopThread implements Runnable {
    private boolean flag = true;

    public void run() {
        while (flag) {
            // try{wait();}catch (InterruptedException e) { System.out.println(Thread.currentThread().getName()+"Exception");} //线程冻结，用interrupt唤醒
            System.out.println(Thread.currentThread().getName() + "....run");
        }
    }

    public void changeFlag()//执行循环结束标记
    {
        flag = false;
    }
}

线程类的其他方法

setDaemon(boolean on)

守护线程，其所守护的线程结束，它本身也结束
public final void setDaemon(boolean on)
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java
虚拟机退出。
该方法必须在启动线程前调用。
该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。
参数：
on - 如果为 true，则将该线程标记为守护线程。
抛出：
IllegalThreadStateException -如果该线程处于活动状态。
SecurityException -如果当前线程无法修改该线程。
另请参见：isDaemon(), checkAccess()

join()

当A线程执行到了B线程的.join()方法时，A就会等待，等B线程都执行完，A才会执行。join可以用来临时加入线程执行。
public final void join()
抛出：
InterruptedException -如果任何线程中断了当前线程。当抛出该异常时，当前线程的 中断状态 被清除。

setPriority(int newPriority)

字段摘要
static int MAX_PRIORITY
线程可以具有的最高优先级。
static int MIN_PRIORITY
线程可以具有的最低优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。

更改线程的优先级。总共1-10，默认优先级是5。MAX_PRIORITY=10、MIN_PRIORITY=1、NORM_PRIORITY=5。
public final void setPriority(int newPriority)
首先调用线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException。
在其他情况下，线程优先级被设定为指定的 newPriority 和该线程的线程组的最大允许优先级相比较小的一个。
参数：
newPriority - 要为线程设定的优先级
抛出：
IllegalArgumentException -如果优先级不在 MIN_PRIORITY 到 MAX_PRIORITY 范围内。
SecurityException -如果当前线程无法修改该线程。
另请参见：
getPriority(), checkAccess(), getThreadGroup(), MAX_PRIORITY, MIN_PRIORITY, ThreadGroup.getMaxPriority()

字段摘要
static int MAX_PRIORITY
线程可以具有的最高优先级。
static int MIN_PRIORITY
线程可以具有的最低优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。

yield()

暂停当前正在执行的线程对象，并执行其他线程。
public static void yield()

toString()

public String toString()
返回：该对象的字符串表示。
通常， toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：getClass().getName() + '@' + Integer.toHexString(hashCode())

习题：运用toString、yield、setPriority 、join

public class JoinDemo {
    public static void main(String[] args) throws Exception {//join需要抛出异常
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t1.setPriority(Thread.MAX_PRIORITY);//优先级 MAX NOR MIN
        t2.start();
        t1.join();//t2被激活后t1插入main，但t1插的是main，所以main会等t1结束再执行，但t2会正常跟t1抢执行权
        for (int x = 0; x < 80; x++) {
            System.out.println("main....."+x);
        }
        System.out.println("over");
    }

}

class Demo implements Runnable {
    public void run() {
        for (int x = 0; x < 70; x++) {
            System.out.println(Thread.currentThread().toString() + "....." + x);
            Thread.yield();//暂停当前
        }
    }
}

线程总结：

线程间通信

等待/唤醒机制。也就是常见的生产者消费者问题。
1. 当多个生产者消费者出现时，
需要让获取执行权的线程判断标记。
通过while完成。
2. 需要将对方的线程唤醒。
仅仅用notify，是不可以的。因为有可能出现只唤醒本方。
有可能会导致，所有线程都等待。
所以可以通过notifyAll的形式来完成 。

这个程序有一个bug。就是每次notifyAll。都会唤醒本方。
可不可以只唤醒对方呢？ JDK1.5版本提供了一些新的对象，优化了等待唤醒机制。

  1. 将synchronized 替换成了Lock接口。
    将隐式锁，升级成了显式锁。
    Lock
    获取锁：lock();
    释放锁：unlock();注意：释放的动作一定要执行，所以通常定义在finally中。
    获取Condition对象：newCondition();
  2. 将Object中的wait，notify，notifyAll方法都替换成了Condition的await，signal，signalAll。
    和以前不同是：
    一个同步代码块具备一个锁，该所以具备自己的独立wait和notify方法。
    现在是将wait，notify等方法，封装进一个特有的对象Condition，而一个Lock锁上可以有多个Condition对象。
Lock lock = new ReentrantLock();
Condition conA = lock.newCondition();
Condition conB = lock.newCondition();
con.await();//生产，，消费
con.signal();生产
set() {
    if(flag)
        conA.await();//生产者，
    code......;
    flag = true;
    conB.signal();
}
out() {
    if(!flag)
        conB.await();//消费者
    code....;
    flag = false;
    conA.signal();
}

wait和sleep的区别：
wait:释放cpu执行权，释放同步中锁。
sleep:释放cpu执行权，不释放同步中锁。

synchronized(锁) {
    wait();
}

停止线程：

stop过时。
原理：run方法结束。run方法中通常定义循环，指定控制住循环线程即可结束。
1，定义结束标记。
2，当线程处于了冻结状态，没有执行标记，程序一样无法结束。
这时可以循环，正常退出冻结状态，或者强制结束冻结状态。
强制结束冻结状态：interrupt();目的是线程强制从冻结状态恢复到运行状态。
但是会发生InterruptedException异常。

线程中一些常见方法：

setDaemon(boolean):将线程标记为后台线程，后台线程和前台线程一样，开启，一样抢执行权运行，只有在结束时，有区别，当前台线程都运行结束后，后台线程会自动结束。
join():等待该线程结束。当A线程执行到了B的.join方法时，A就会处于冻结状态。A什么时候运行呢？当B运行结束后，A就会具备运行资格，继续运行。
加入线程，可以完成对某个线程的临时加入执行。

线程状态转换

JAVA 线程_第2张图片

各种状态一目了然，值得一提的是”blocked”这个状态：
线程在Running的过程中可能会遇到阻塞(Blocked)情况

  1. 调用join()和sleep()方法，sleep()时间结束或被打断，join()中断,IO完成都会回到Runnable状态，等待JVM的调度。
  2. 调用wait()，使该线程处于等待池(wait blocked pool),直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable）
  3. 对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。

多线程重点：

1，多线程的创建的两种方式，以及区别。
2， 同步的特点。
同步的好处：
同步的弊端：
同步的前提：
同步的表现形式以及区别。
特例：static同步函数锁是哪一个。
死锁代码要求写的出来。
3，线程间通信，看以上总结。
4，wait和sleep， yield：临时暂停，可以让线程是释放执行权。

线程池

简述线程池

线程池是如何工作的：一系列任务出现后，根据自己的线程池安排任务进行。

如图：


JAVA 线程_第3张图片

线程池的好处

  1. 重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
  2. 能有效控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。
  3. 能对线程进行简单的管理。并提供定时执行以及指定间隔循环执行等功能。

ThreadPoolExecutor

JAVA语言为我们提供了两种基础线程池的选择：ScheduledThreadPoolExecutor和ThreadPoolExecutor。它们都实现了ExecutorService接口（注意，ExecutorService接口本身和“线程池”并没有直接关系，它的定义更接近“执行器”，而“使用线程管理的方式进行实现”只是其中的一种实现方式）。这篇文章中，我们主要围绕ThreadPoolExecutor类进行讲解。

线程池的具体实现为ThreadPoolExeutor,其接口为Executor。

ThreadPoolExecutor逻辑结构

ThreadPoolExecutor提供了一系列的参数用于配置线程池。

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                              TimeUnit unit, BlockingQueue workQueue,
                              ThreadFactory threadFactory) { 
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);
}

参数含义如下：

  1. corePoolSize : 线程池核心线程数，默认情况下，核心线程会在线程池中一直存活，即使他们处于闲置状态。
    其有一个allowCoreThreadTimeOut属性如果设置为true,那么核心线程池会有超时策略。超时的时长为第三个参数 keepAliveTime 。如果超时，核心线程会被终结。
  2. maxmumPoolSize: 线程池所能容忍的最大线程数，当活动线程数达到这个数值后，后续的新任务会被阻塞。
  3. keepAliveTime: 非核心线程闲置时的超时时长，超过这个时长非核心线程会被回收。这个参数如同第一个参数，如果设置相关属性后也会作用于核心线程。
  4. unit: 指定keepAliveTime的参数时间单位。这是一个枚举，常用的有MILLISECONDS（毫秒）、SECONDS（秒）等
  5. workQueue: 线程池的任务队列，通过execute()方法（执行方法）提交的Runable对象会存储在这个参数中。
  6. threadFactory: 线程工厂，为线程池提供创建新线程的功能。

JAVA 线程_第4张图片
[]

一定要注意一个概念，即 存在于线程池中容器的一定是Thread对象，而不是你要求运行的任务（所以叫线程池而不叫任务池也不叫对象池）；你要求运行的 任务将被线程池分配给某一个空闲的Thread运行。

从上图中，我们可以看到构成线程池的几个重要元素：
● 等待队列：顾名思义，就是你调用线程池对象的submit()方法或者execute()方法，要求线程池运行的任务（这些任务必须实现Runnable接口或者Callable接口）。但是出于某些原因线程池并没有马上运行这些任务，而是送入一个队列等待执行。

● 核心线程：线程池主要用于执行任务的是“核心线程”，“核心线程”的数量是你创建线程时所设置的corePoolSize参数决定的。如果不进行特别的设定，线程池中始终会保持corePoolSize数量的线程数（不包括创建阶段）。

● 非核心线程：一旦任务数量过多（由等待队列的特性决定），线程池将创建“非核心线程”临时帮助运行任务。你设置的大于corePoolSize参数小于maximumPoolSize参数的部分，就是线程池可以临时创建的“非核心线程”的最大数量。这种情况下如果某个线程没有运行任何任务，在等待keepAliveTime时间后，这个线程将会被销毁，直到线程池的线程数量重新达到corePoolSize。

● maximumPoolSize参数也是当前线程池允许创建的最大线程数量。那么如果设置的corePoolSize参数和设置的maximumPoolSize参数一致时，线程池在任何情况下都不会回收空闲线程。keepAliveTime和timeUnit也就失去了意义。

● keepAliveTime参数和timeUnit参数也是配合使用的。keepAliveTime参数指明等待时间的量化值，timeUnit指明量化值单位。例如keepAliveTime=1，timeUnit为TimeUnit.MINUTES，代表空闲线程的回收阀值为1分钟。

ThreadPoolExecutor工作方式

线程池是怎样处理某一个运行任务的

  1. 首先可以通过线程池提供的submit()方法或者execute()方法，要求线程池执行某个任务。线程池收到这个要求执行的任务后，会有几种处理情况：
    1.1、如果当前线程池中运行的线程数量还没有达到corePoolSize大小时，线程池会创建一个新的线程运行你的任务，无论之前已经创建的线程是否处于空闲状态。
    1.2、如果当前线程池中运行的线程数量已经达到设置的corePoolSize大小，线程池会把你的这个任务加入到等待队列（workQueue）中。直到某一个的线程空闲了，线程池会根据设置的等待队列规则，从队列中取出一个新的任务执行。
    1.3、如果根据队列规则，这个任务无法加入等待队列。（当workQueue已满，且maximumPoolSize>corePoolSize时）这时线程池就会创建一个“非核心线程”直接运行这个任务。注意，如果这种情况下任务执行成功，那么当前线程池中的线程数量一定大于corePoolSize。
    1.4、如果这个任务，无法被“核心线程”直接执行，又无法加入等待队列，又无法创建“非核心线程”直接执行，且你没有为线程池设置RejectedExecutionHandler。（当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理）这时线程池会抛出RejectedExecutionException异常，即线程池拒绝接受这个任务。（实际上抛出RejectedExecutionException异常的操作，是ThreadPoolExecutor线程池中一个默认的RejectedExecutionHandler实现：AbortPolicy，这在后文会提到）
  2. 一旦线程池中某个线程完成了任务的执行，它就会试图到任务等待队列中拿去下一个等待任务（所有的等待任务都实现了BlockingQueue接口，按照接口字面上的理解，这是一个可阻塞的队列接口），它会调用等待队列的poll()方法，并停留在哪里。
  3. 当线程池中的线程超过你设置的corePoolSize参数，说明当前线程池中有所谓的“非核心线程”。那么当某个线程处理完任务后，如果等待keepAliveTime时间后仍然没有新的任务分配给它，那么这个线程将会被回收。线程池回收线程时，对所谓的“核心线程”和“非核心线程”是一视同仁的，直到线程池中线程的数量等于你设置的corePoolSize参数时，回收过程才会停止。（当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程）
    当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭。

ThreadPoolExecutor不常用的设置

在ThreadPoolExecutor线程池中，有一些不常用的甚至不需要的设置

allowCoreThreadTimeOut：

线程池回收线程只会发生在当前线程池中线程数量大于corePoolSize参数的时候；当线程池中线程数量小于等于corePoolSize参数的时候，回收过程就会停止。
allowCoreThreadTimeOut设置项可以要求线程池：将包括“核心线程”在内的，没有任务分配的任何线程，在等待keepAliveTime时间后全部进行回收：

ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 1, TimeUnit.MINUTES, new ArrayBlockingQueue(1)); 
poolExecutor.allowCoreThreadTimeOut(true);

以下是设置前的效果：


JAVA 线程_第5张图片
[]

以下是设置后的效果：


JAVA 线程_第6张图片
[]
prestartAllCoreThreads

前文我们还讨论到，当线程池中的线程还没有达到你设置的corePoolSize参数值的时候，如果有新的任务到来，线程池将创建新的线程运行这个任务，无论之前已经创建的线程是否处于空闲状态。这个描述可以用下面的示意图表示出来：


JAVA 线程_第7张图片
[]

prestartAllCoreThreads设置项，可以在线程池创建，但还没有接收到任何任务的情况下，先行创建符合corePoolSize参数值的线程数：

ThreadPoolExecutor poolExecutor =new ThreadPoolExecutor(5,10,1, TimeUnit.MINUTES, new ArrayBlockingQueue(1));
poolExecutor.prestartAllCoreThreads();

上面给出的最简单的ThreadPoolExecutor线程池的使用方式中，我们只采用了ThreadPoolExecutor最简单的一个构造函数：

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)

实际上ThreadPoolExecutor线程池有很多种构造函数，其中最复杂的一种构造函数是：

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

ThreadFactory的使用

线程池最主要的一项工作，就是在满足某些条件的情况下创建线程。而在ThreadPoolExecutor线程池中，创建线程的工作交给ThreadFactory来完成。要使用线程池，就必须要指定ThreadFactory。
类似于上文中，如果我们使用的构造函数时并没有指定使用的ThreadFactory，这个时候ThreadPoolExecutor会使用一个默认的ThreadFactory：DefaultThreadFactory。（这个类在Executors工具类中）

当然，在某些特殊业务场景下，还可以使用一个自定义的ThreadFactory线程工厂，如下代码片段：

import java.util.concurrent.ThreadFactory;
/* 测试自定义的一个线程工厂 */
public class TestThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r);
    }
}

线程池的等待队列

在使用ThreadPoolExecutor线程池的时候，需要指定一个实现了BlockingQueue接口的任务等待队列。在ThreadPoolExecutor线程池的API文档中，一共推荐了三种等待队列，它们是：SynchronousQueue、LinkedBlockingQueue和ArrayBlockingQueue；

队列和栈

● 队列：是一种特殊的线性结构，允许在线性结构的前端进行删除/读取操作；允许在线性结构的后端进行插入操作；这种线性结构具有“先进先出”的操作特点：

JAVA 线程_第8张图片
[]

但是在实际应用中，队列中的元素有可能不是以“进入的顺序”为排序依据的。例如我们将要讲到的PriorityBlockingQueue队列。

● 栈：栈也是一种线性结构，但是栈和队列相比只允许在线性结构的一端进行操作，入栈和出栈都是在一端完成。

JAVA 线程_第9张图片
[]

1. 有限队列

● SynchronousQueue：

是这样 一种阻塞队列，其中每个 put 必须等待一个 take，反之亦然。同步队列没有任何内部容量。
翻译一下：这是一个内部没有任何容量的阻塞队列，任何一次插入操作的元素都要等待相对的删除/读取操作，否则进行插入操作的线程就要一直等待，反之亦然。

SynchronousQueue queue = new SynchronousQueue(); 
// 不要使用add，因为这个队列内部没有任何容量，所以会抛出异常“IllegalStateException”
// queue.add(new Object()); 
// 操作线程会在这里被阻塞，直到有其他操作线程取走这个对象
queue.put(new Object());


● ArrayBlockingQueue：


一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。这是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞；试图从空队列中提取元素将导致类似阻塞。


// 我们创建了一个ArrayBlockingQueue，并且设置队列空间为2 
ArrayBlockingQueue arrayQueue = new ArrayBlockingQueue(2); 
// 插入第一个对象 
arrayQueue.put(new Object()); 
// 插入第二个对象 
arrayQueue.put(new Object()); 
// 插入第三个对象时，这个操作线程就会被阻塞。 
arrayQueue.put(new Object()); 
// 请不要使用add操作，和SynchronousQueue的add操作一样，它们都使用了AbstractQueue中的add实现


2.无限队列


● LinkedBlockingQueue：


LinkedBlockingQueue是我们在ThreadPoolExecutor线程池中常用的等待队列。它可以指定容量也可以不指定容量。由于它具有“无限容量”的特性，所以我还是将它归入了无限队列的范畴（实际上任何无限容量的队列/栈都是有容量的，这个容量就是Integer.MAX_VALUE）。
 LinkedBlockingQueue的实现是基于链表结构，而不是类似ArrayBlockingQueue那样的数组。但实际使用过程中，不需要关心它的内部实现，如果指定了LinkedBlockingQueue的容量大小，那么它反映出来的使用特性就和ArrayBlockingQueue类似了。


LinkedBlockingQueue linkedQueue = new LinkedBlockingQueue(2); 
linkedQueue.put(new Object()); 
// 插入第二个对象 
linkedQueue.put(new Object()); 
// 插入第三个对象时，这个操作线程就会被阻塞。 
linkedQueue.put(new Object());


// 或者如下使用： 
LinkedBlockingQueue linkedQueue = new LinkedBlockingQueue(); 
linkedQueue.put(new Object()); 
// 插入第二个对象 
linkedQueue.put(new Object()); 
// 插入第N个对象时，都不会阻塞 linkedQueue.put(new Object());


● LinkedBlockingDeque


LinkedBlockingDeque是一个基于链表的双端队列。
 LinkedBlockingQueue的内部结构决定了它只能从队列尾部插入，从队列头部取出元素；
 但是LinkedBlockingDeque既可以从尾部插入/取出元素，还可以从头部插入元素/取出元素。


LinkedBlockingDeque linkedDeque = new LinkedBlockingDeque(); 
// push ，可以从队列的头部插入元素 
linkedDeque.push(new TempObject(1)); 
linkedDeque.push(new TempObject(2)); 
linkedDeque.push(new TempObject(3)); 

// poll ， 可以从队列的头部取出元素 
TempObject tempObject = linkedDeque.poll(); 
// 这里会打印 tempObject.index = 3 
System.out.println("tempObject.index = " + tempObject.getIndex()); 

// put ， 可以从队列的尾部插入元素 
linkedDeque.put(new TempObject(4)); 
linkedDeque.put(new TempObject(5)); 

// pollLast , 可以从队列尾部取出元素 
tempObject = linkedDeque.pollLast(); 
// 这里会打印 tempObject.index = 5 
System.out.println("tempObject.index = " + tempObject.getIndex());



● PriorityBlockingQueue


PriorityBlockingQueue是一个按照优先级进行内部元素排序的无限队列。
 存放在PriorityBlockingQueue中的元素必须实现Comparable接口，这样才能通过实现compareTo()方法进行排序。优先级最高的元素将始终排在队列的头部；PriorityBlockingQueue不会保证优先级一样的元素的排序，也不保证当前队列中除了优先级最高的元素以外的元素，随时处于正确排序的位置。
 这是什么意思呢？PriorityBlockingQueue并不保证除了队列头部以外的元素排序一定是正确的。请看下面的示例代码：


PriorityBlockingQueue priorityQueue = new PriorityBlockingQueue();
priorityQueue.put(new TempObject(-5));
priorityQueue.put(new TempObject(5));
priorityQueue.put(new TempObject(-1));
priorityQueue.put(new TempObject(1));
// 第一个元素是5 
TempObject targetTempObject = priorityQueue.poll();
System.out.println("tempObject.index = " + targetTempObject.getIndex());
// 实际上在还没有执行priorityQueue.poll()语句的时候，队列中的第二个元素不一定是1 
// 第二个元素是1 
targetTempObject = priorityQueue.poll();
System.out.println("tempObject.index = " + targetTempObject.getIndex());
// 第三个元素是-1 
targetTempObject = priorityQueue.poll();
System.out.println("tempObject.index = " + targetTempObject.getIndex());
// 第四个元素是-5 
targetTempObject = priorityQueue.poll();
System.out.println("tempObject.index = " + targetTempObject.getIndex());



// 这个元素类，必须实现Comparable接口 
private static class TempObject implements Comparable {
    private int index;
    public TempObject(int index) {
        this.index = index;
    }
    public int getIndex() {
        return index;
    }
    @Override
    public int compareTo(TempObject o) {
        return o.getIndex() - this.index;
    }
}



● LinkedTransferQueue


LinkedTransferQueue也是一个无限队列，它除了具有一般队列的操作特性外（先进先出），还具有一个阻塞特性：LinkedTransferQueue可以由一对生产者/消费者线程进行操作，当消费者将一个新的元素插入队列后，消费者线程将会一直等待，直到某一个消费者线程将这个元素取走，反之亦然。
 LinkedTransferQueue的操作特性可以由下面这段代码提现。在下面的代码片段中，有两中类型的线程：生产者和消费者，这两类线程互相等待对方的操作：


/* 消费者线程 */
private static class ConsumerRunnable implements Runnable {
    private LinkedTransferQueue linkedQueue;
    public ConsumerRunnable(LinkedTransferQueue linkedQueue) {
        this.linkedQueue = linkedQueue;
    }

    @Override
    public void run() {
        Thread currentThread = Thread.currentThread();
        while (!currentThread.isInterrupted()) {
            try { // 等待，直到从LinkedTransferQueue队列中得到一个元素
                TempObject targetObject = this.linkedQueue.take();
                System.out.println("线程（" + currentThread.getId() + "）取得targetObject.index = " + targetObject.getIndex());
            } catch (InterruptedException e) {
                e.printStackTrace(System.out);
            }
        }
    }
}



//以下是启动代码：
LinkedTransferQueue linkedQueue = new LinkedTransferQueue(); 
// 这是一个生产者线程 
Thread producerThread = new Thread(new ProducerRunnable(linkedQueue)); 
// 这里有两个消费者线程 
Thread consumerRunnable1 = new Thread(new ConsumerRunnable(linkedQueue)); 
Thread consumerRunnable2 = new Thread(new ConsumerRunnable(linkedQueue)); 
// 开始运行 
producerThread.start(); 
consumerRunnable1.start(); 
consumerRunnable2.start(); 
// 这里只是为了main不退出，没有任何演示含义 
Thread currentThread = Thread.currentThread(); 
synchronized (currentThread) { currentThread.wait(); }



拒绝任务（handler）


在ThreadPoolExecutor线程池中还有一个重要的接口：RejectedExecutionHandler。当提交给线程池的某一个新任务无法直接被线程池中“核心线程”直接处理，又无法加入等待队列，也无法创建新的线程执行；又或者线程池已经调用shutdown()方法停止了工作；又或者线程池不是处于正常的工作状态；这时候ThreadPoolExecutor线程池会拒绝处理这个任务，触发创建ThreadPoolExecutor线程池时定义的RejectedExecutionHandler接口的实现


在创建ThreadPoolExecutor线程池时，一定会指定RejectedExecutionHandler接口的实现。如果调用的是不需要指定RejectedExecutionHandler接口的构造函数，如：


public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) 
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory)



那么ThreadPoolExecutor线程池在创建时，会使用一个默认的RejectedExecutionHandler接口实现，源代码片段如下：


public class ThreadPoolExecutor extends AbstractExecutorService { ......
    /**
     * The default rejected execution handler
     */
    private static final RejectedExecutionHandler defaultHandler = new AbortPolicy(); ......
// 可以看到，ThreadPoolExecutor中的两个没有指定RejectedExecutionHandler
// 接口的构造函数，都是使用了一个RejectedExecutionHandler接口的默认实现：AbortPolicy

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler);
    } ......

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);
    } ......
}



实际上，在ThreadPoolExecutor中已经提供了四种可以直接使用的RejectedExecutionHandler接口的实现：


● CallerRunsPolicy：
 这个拒绝处理器，将直接运行这个任务的run方法。但是，请注意并不是在ThreadPoolExecutor线程池中的线程中运行，而是直接调用这个任务实现的run方法。源代码如下：


public static class CallerRunsPolicy implements RejectedExecutionHandler {
    /**
     * Creates a {@code CallerRunsPolicy}.
     */
    public CallerRunsPolicy() {
    }

    /**
     * Executes task r in the caller's thread, unless the executor * has been shut down, in which case the task is discarded. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}



● AbortPolicy：


这个处理器，在任务被拒绝后会创建一个RejectedExecutionException异常并抛出。这个处理过程也是ThreadPoolExecutor线程池默认的RejectedExecutionHandler实现。


● DiscardPolicy：
 DiscardPolicy处理器，将会默默丢弃这个被拒绝的任务，不会抛出异常，也不会通过其他方式执行这个任务的任何一个方法，更不会出现任何的日志提示。


● DiscardOldestPolicy：
 这个处理器很有意思。它会检查当前ThreadPoolExecutor线程池的等待队列。并调用队列的poll()方法，将当前处于等待队列列头的等待任务强行取出，然后再试图将当前被拒绝的任务提交到线程池执行：


public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    ......
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    } 
    ......
}



实际上查阅这四种ThreadPoolExecutor线程池自带的拒绝处理器实现，您可以发现CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy处理器针对被拒绝的任务并不是一个很好的处理方式。
 CallerRunsPolicy在非线程池以外直接调用任务的run方法，可能会造成线程安全上的问题；DiscardPolicy默默的忽略掉被拒绝任务，也没有输出日志或者提示，开发人员不会知道线程池的处理过程出现了错误；DiscardOldestPolicy中e.getQueue().poll()的方式好像是科学的，但是如果等待队列出现了容量问题，大多数情况下就是这个线程池的代码出现了BUG。
 最科学的的还是AbortPolicy提供的处理方式：抛出异常，由开发人员进行处理。


常用的几种线程池


1. newCachedThreadPool


创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。


这种类型的线程池特点是：


    

  • 工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
    • 

  • 如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
    • 

  • 在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。
    • 



示例代码如下：


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //Executors.newCachedThreadPool()
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(index);
                }
            });
        }
    }
}



2. newFixedThreadPool


创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。


FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。


示例代码如下：


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //Executors.newFixedThreadPool
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}



因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
 定长线程池的大小最好根据系统资源进行设置如Runtime.getRuntime().availableProcessors()。


3. newSingleThreadExecutor


创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。
 单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。


示例代码如下：


public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
} 



4. newScheduleThreadPool


创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。


延迟3秒执行，延迟执行示例代码如下：


public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //scheduledThreadPool.schedule
        scheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println("delay seconds");
            }
        }, 3, TimeUnit.SECONDS);//延迟3秒执行
    }
}



表示延迟1秒后每3秒执行一次，定期执行示例代码如下：


public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //scheduledThreadPool.scheduleAtFixedRate
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("delay seconds, and excute every seconds");
            }
        }, 1, 3, TimeUnit.SECONDS);//延迟1秒后每3秒执行一次
    }
}



引用：
 关于Java中的程序，进程和线程的详解...
 java/android线程池详解
 线程池的使用（ThreadPoolExecutor详解）
 Java中的多线程你只要看这一篇就够了
 java常用的几种线程池比较
























你可能感兴趣的:(JAVA 线程)






    

  • 【网络安全】漏洞挖掘：php代码审计
秋说
网络安全phpweb安全漏洞挖掘

    未经许可，不得转载。文章目录正文正文在应用程序中，通过一个JavaScript注释发现了一个备份ZIP文件。解压后，获取了应用程序的代码，其中包含如下代码片段：代码首先检查变量$action是否等于'convert'，如果是，则继续执行。随后对传入的变量$data使用trim()函数去除两端空白字符，并使用eval()函数执行$data的内容。显然，代码对$data没有进行任何过滤或验证，因此可以
    

    • 

  • 前端基础面试题·第三篇——JavaScript（其二）
DT——
前端面试javascript面试

    1.深浅拷贝1.浅拷贝浅拷贝会创建一个新的对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝就是改引用类型的地址。//常见的浅拷贝1.Object.assign({},obj)//对象浅拷贝assign⽅法可以⽤于处理数组，不过会把数组视为对象，⽐如这⾥会把⽬标数组视为是属性为0、1、2的对象，所以源数组的0、1属性的值覆盖了⽬标对
    

    • 

  • 面试问题001
li星野
刷题面试开发语言linux

    进程和线程的区别进程是资源分配和调度的基本单位。线程是程序执行的最小单位，线程是进程的子任务，是进程内的执行单元。一个进程至少有一个线程，一个进程可以运行多个线程，这些线程共享同一块内存。资源开销：进程：由于每个进程都有独立的内存空间，创建和销毁进程的开销较大。进程间切换需要保存和恢复整个进程的状态，因此上下文切换的开销较高。线程：线程共享相同的内存空间，创建和销毁线程的开销较小。线程间切换只需要
    

    • 

  • 【网络安全 | 代码审计】JFinal之DenyAccessJsp绕过
秋说
网络安全web安全java代码审计漏洞挖掘

    未经许可，不得转载。文章目录前言代码审计推理绕过Tomcat解析JSP总结概念验证阐发前言JFinal是一个基于Java的轻量级MVC框架，用于快速构建Web应用程序。它的设计理念是追求极简、灵活、高效，旨在提高开发效率，减少冗余代码的编写，适合中小型项目以及对性能有较高要求的项目。在较新的JFinal版本中，默认情况下无法直接通过浏览器地址栏输入.jsp文件名来访问对应的JSP文件。也就是说，主
    

    • 

  • Visual Studio中的Android模拟器使用详解
wurui8
androidandroidstudioandroidandroid应用

    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
    

    • 

  • 常用类库 Guava 简介
豆瑞瑞
java

    简介GoogleGuava是一个由Google开发的Java开源函数库。前身是GoogleCollectionsLibrary，提供了许多简化工具，如缓存、连接器、过滤器、关联数组等仓库代码GitCode-全球开发者的开源社区,开源代码托管平台参考https://github.com/google/guavahttps://github.com/google/guava/wikiRedisStre
    

    • 

  • python 多线程抓取xunlei磁力下载链接
weixin_53748624
pythonpycharm

    importurllib.requestimportreimporttimeimportthreadingclassSpider(object):def__init__(self):#定义字典，用于保存影片信息self.films_dict={}self.i=1self.lock1=threading.Lock()defstart(self):#调用下载函数，获取下载连接forpageinrang
    

    • 

  • JAVA相关知识
M_灵均
javajvm开发语言

    JAVA基础知识说一下对象创建的过程？类加载检查：当Java虚拟机（JVM）遇到一个类的new指令时，它首先检查这个类是否已经被加载、链接和初始化。如果没有，JVM会通过类加载器（ClassLoader）加载这个类。分配内存：JVM为新对象分配内存。这个内存分配是在堆（Heap）上进行的，堆是JVM用来存储对象实例的地方。分配内存的大小在类加载时就已经确定，因为类的结构（包括字段和方法）已经确定。
    

    • 

  • Kotlin 代替Java接口回调，就这么简单
深海呐
Android#Kotlinjavakotlin开发语言

    假如你使用旧的接口回调：通常三步：1定义接口和方法；2使用接口中方法；3继承接口并实现方法；例：classXXXAdapter{publicvarmClickCollBack:clickCollBack?=null//1定义interfaceclickCollBack{//1定义funclick(int:Int)//1定义}itemView.setOnClickListener{mClickCol
    

    • 

  • Android 用线程池实现一个简单的任务队列(Kotlin)
深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务

    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
    

    • 

  • （小白入门）Windows环境下搭建React Native Android开发环境
码农老黑
前端ReactNative移动开发Androidstudio

    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
    

    • 

  • Java刷题day34
小突击花呀
刷题java网络服务器

    1.IPv4版本的因特网总共有多少有效A类地址网络（）A.255B.128C.256D.126答案：D解析：A类IP地址范围从1.0.0.0到126.0.0.0。可用的A类网络有126个。B类IP地址范围从128.0.0.0到191.255.255.255。可用的B类网络有16382个。C类IP地址范围从192.0.0.0到223.255.255.255。C类网络可达209万余个。D类地址用于多点
    

    • 

  • Android界面特效全汇总
小飞鹤
Android开发详解android

    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
    

    • 

  • Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码 及 功能清单
Xiaohong0716
mybatisjavaspringcloud

    一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
    

    • 

  • 笔记：JAVA面向对象三大特征——封装继承多态
听原来是雨落
Javajava开发语言后端

    高内聚，低耦合：  高内聚：类的内部数据操作细节自己完成，不允许外部干涉；    低耦合：仅暴露少量的方法给外部使用。一、封装：  含义：1.指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个密不可分的独立单位（即对象）中；     2.指“信息隐藏”，把不需要外界知道的信息隐藏起来，有些对象的属性及行为为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知道，
    

    • 

  • 【JavaSE】封装、继承与多态
泡芙冰淇淋ya
JavaSEjava开发语言

    1、封装1.1简介在Javase中，封装（Encapsulation）是面向对象编程（OOP）的一个重要概念。封装的主要目的是隐藏对象的内部状态和信息，只提供必要的公共方法来访问和操作这些状态和信息。通过封装可以控制对对象内部数据的访问级别，并保护数据不被随意修改，从而提高代码的安全性和可维护性。1.2特点信息隐藏：对象的内部状态（即属性或数据成员）被隐藏起来，外部世界只能通过对象提供的方法来访问
    

    • 

  • 02 Java-Lambda-Java 8 自带的函数接口
王小杰at2019

    Java8自带的函数接口我们使用lambda在处理自己定义的业务时，需要自定义函数式接口，其实java8已经内置了常用的接口，这样我们在用的时候不要需要自己定义接口，根据需要选择符合自己业务逻辑的接口接口|输入参数|返回值类型|说明---|---|---|---|---Predicate|T|boolean|断言Consumer|T|/|消费一个数据|Function|T|R|输入一个T输出一个R
    

    • 

  • JavaSE:4、流程控制
_Power_Y
JavaSEjava算法开发语言

    1、代码块与作用域变量的使用范围，仅限于其定义时所处的代码块，也就是他的作用域。目前所说的变量均为局部变量publicclassMain{publicstaticvoidmain(String[]argv){inta=10;{intb=10;System.out.println(a);System.out.println(b);}System.out.println(a);//System.out
    

    • 

  • Java并发编程-AQS详解及案例实战（上篇）
猿与禅
Java技术栈源码分析javaAQS并发编程原理

    文章目录AQS概述AQS的核心概念AQS的工作原理AQS的灵活性使用场景使用指南使用示例AQS的本质:为啥叫做异步队列同步器AQS的核心机制“异步队列”的含义“同步器”的含义总结加锁失败的时候如何借助AQS异步入队阻塞等待AQS的锁队列加锁失败时的处理流程异步入队的机制总结ReentractLock如何设置公平锁策略以及原理设置公平锁策略公平锁的运作原理尝试获取锁释放锁性能与公平性的权衡tryLo
    

    • 

  • 计算机毕业设计Node.js+Vue基于Java的医院预约挂号系统(程序+源码+LW+部署)
Nodejs洋洋 程序
javavue.js课程设计

    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：Node.js+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：Express框架+Node.js+Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可
    

    • 

  • Java高并发编程详解系列-深入理解Thread构造
nihui123
高并发Java高并发Java高并发

    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
    

    • 

  • Java高并发编程详解系列-Balking设计模式
nihui123
高并发设计模式java编程语言

    导语  在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式  在餐厅吃饭的时
    

    • 

  • Java高并发编程详解系列-Future设计模式
nihui123
高并发Java高并发Future高并发

    导语  假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
    

    • 

  • ajax讲解
夜不眠，码三千
okhttp

    1.AJAX概述1.1什么是ajaxAJAX（AsynchronousJavascriptAndXML）翻译成中文就是“异步Javascript和XML”。即使用Javascript语言与服务器进行异步交互，传输的数据为XML（当然，传输的数据不只是XML）。AJAX还有一个最大的特点就是，当服务器响应时，不用刷新整个浏览器页面，而是可以局部刷新。这一特点给用户的感受是在不知不觉中完成请求和响应过
    

    • 

  • Java岗外包干了五年，废了。。。
跟着我学Java
面试Java程序员javajvm面试程序人生架构

    先说一下自己的个人情况，大专生，17年通过校招进入湖南某软件公司，干了接近5年的CRUD，今年年初，感觉自己不能够在这样下去了，长时间呆在一个舒适的环境会让一个人堕落!而我已经在一个企业干了五年的CRUD，已经让我变得不思进取，谈了3年的女朋友也因为我的心态和工资和我分手了。于是，我决定要改变现状刚开始准备时，自己都蒙了，五年的CRUD让我的技术没有一丝的进步，提升的只有我的年龄...没办法，我找
    

    • 

  • python基于django/flask的NBA球员大数据分析与可视化python+java+node.js
QQ_511008285
pythondjangoflaskjavaspringboot数据分析

    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
    

    • 

  • Java基于spring boot的国产电影数据分析与可视化python+java+node.js
QQ_511008285
javaspringboot数据分析pythondjangovue.jsflask

    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以  该系统使用进行大数据处理和
    

    • 

  • MTK Camera2 预览图成像质量差（马赛克）
AQUARICES
Androidjavaandroid

    MTK推送来的原生Camera2应用拍照之后生成的预览图（Thumbnail）居然是马赛克！！但如果点击预览图之后再退出，就又是正常的。Camera2对于更新预览图的操作位于：vendor/mediatek/proprietary/packages/apps/Camera2/host/src/com/mediatek/camera/ui/ThumbnailViewManager.java这个函数对
    

    • 

  • Java中的多态性（Polymorphism）
天蓝蓝23528
java开发语言

    Java中的多态性（Polymorphism）是面向对象编程（OOP）中的一个核心概念，它允许同一个接口或方法在不同对象上具有不同的实现方式。多态性极大地提高了代码的灵活性和可扩展性，使得程序能够以一种统一的方式处理不同类型的对象。以下是对Java中多态性的详细解释，包括其定义、实现方式、优点以及具体示例。一、多态性的定义多态性是指允许不同类的对象对同一消息作出响应，即同一操作作用于不同的对象，可
    

    • 

  • 如何实现Java中的多态性
Good_tea_h
javapython开发语言

    Java中的多态性是一个核心概念，它允许对象在其所属的类层次结构中有多种表现形式。多态性的实现主要依赖于继承、方法重写以及接口实现等机制。以下将详细阐述Java中多态性的实现方式，并探讨其原理、作用及优势。一、多态性的定义多态性（Polymorphism）在Java中指的是允许不同类的对象对同一消息作出不同的响应。简单来说，就是同一个方法调用，作用于不同的对象，可以有不同的执行结果。多态性增强了程
    

    • 

  • 矩阵求逆（JAVA）利用伴随矩阵
qiuwanchi
利用伴随矩阵求逆矩阵

    package gaodai.matrix;
import gaodai.determinant.DeterminantCalculation;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* 矩阵求逆(利用伴随矩阵)
* @author 邱万迟

    

    • 

  • 单例（Singleton）模式
aoyouzi
单例模式Singleton

    3.1           概述 如果要保证系统里一个类最多只能存在一个实例时，我们就需要单例模式。这种情况在我们应用中经常碰到，例如缓存池，数据库连接池，线程池，一些应用服务实例等。在多线程环境中，为了保证实例的唯一性其实并不简单，这章将和读者一起探讨如何实现单例模式。 3.2
    

    • 

  • [开源与自主研发]就算可以轻易获得外部技术支持,自己也必须研发
comsci
开源

    
      现在国内有大量的信息技术产品，都是通过盗版，免费下载，开源，附送等方式从国外的开发者那里获得的。。。。。。
       虽然这种情况带来了国内信息产业的短暂繁荣，也促进了电子商务和互联网产业的快速发展，但是实际上，我们应该清醒的看到，这些产业的核心力量是被国外的
    

    • 

  • 页面有两个frame,怎样点击一个的链接改变另一个的内容
Array_06
UIXHTML

    <a src="地址"  targets="这里写你要操作的Frame的名字" />搜索
然后你点击连接以后你的新页面就会显示在你设置的Frame名字的框那里
targerts="",就是你要填写目标的显示页面位置
=====================
例如：
<frame src=&
    

    • 

  • Struts2实现单个/多个文件上传和下载
oloz
文件上传struts

    struts2单文件上传：
    步骤01:jsp页面
<!--在进行文件上传时，表单提交方式一定要是post的方式，因为文件上传时二进制文件可能会很大，还有就是enctype属性，这个属性一定要写成multipart/form-data，不然就会以二进制文本上传到服务器端-->
　　<form action="fileUplo
    

    • 

  • 推荐10个在线logo设计网站
362217990
logo

    在线设计Logo网站。
1、http://flickr.nosv.org（这个太简单）
2、http://www.logomaker.com/?source=1.5770.1
3、http://www.simwebsol.com/ImageTool
4、http://www.logogenerator.com/logo.php?nal=1&tpl_catlist[]=2
5、ht
    

    • 

  • jsp上传文件
香水浓
jspfileupload

    1. jsp上传
Notice：
1. form表单 method 属性必须设置为 POST 方法 ，不能使用 GET 方法
2. form表单 enctype 属性需要设置为 multipart/form-data
3. form表单 action 属性需要设置为提交到后台处理文件上传的jsp文件地址或者servlet地址。例如 uploadFile.jsp 程序文件用来处理上传的文
    

    • 

  • 我的架构经验系列文章 - 前端架构
agevs
JavaScriptWeb框架UIjQuer

    框架层面：近几年前端发展很快，前端之所以叫前端因为前端是已经可以独立成为一种职业了，js也不再是十年前的玩具了，以前富客户端RIA的应用可能会用flash/flex或是silverlight，现在可以使用js来完成大部分的功能，因此js作为一门前端的支撑语言也不仅仅是进行的简单的编码，越来越多框架性的东西出现了。越来越多的开发模式转变为后端只是吐json的数据源，而前端做所有UI的事情。MVCMV
    

    • 

  • android ksoap2 中把XML(DataSet) 当做参数传递
aijuans
android

    我的android app中需要发送webservice ，于是我使用了 ksop2 进行发送，在测试过程中不是很顺利,不能正常工作.我的web service 请求格式如下  
 
[html] 
view plain
copy  
<Envelope xmlns="http://schemas.
    

    • 

  • 使用Spring进行统一日志管理 + 统一异常管理
baalwolf
spring

    统一日志和异常管理配置好后，SSH项目中，代码以往散落的log.info() 和 try..catch..finally 再也不见踪影！
统一日志异常实现类：
[java] 
view plain
copy  
package com.pilelot.web.util;  
  
impor
    

    • 

  • Android SDK 国内镜像
BigBird2012
android sdk

    一、镜像地址：
1、东软信息学院的 Android SDK 镜像，比配置代理下载快多了。
配置地址， http://mirrors.neusoft.edu.cn/configurations.we#android
2、北京化工大学的：
IPV4:ubuntu.buct.edu.cn 
IPV4:ubuntu.buct.cn
IPV6:ubuntu.buct6.edu.cn

    

    • 

  • HTML无害化和Sanitize模块
bijian1013
JavaScriptAngularJSLinkySanitize

    一.ng-bind-html、ng-bind-html-unsafe
        AngularJS非常注重安全方面的问题，它会尽一切可能把大多数攻击手段最小化。其中一个攻击手段是向你的web页面里注入不安全的HTML，然后利用它触发跨站攻击或者注入攻击。
        考虑这样一个例子，假设我们有一个变量存
    

    • 

  • [Maven学习笔记二]Maven命令
bit1129
maven

    mvn compile
compile编译命令将src/main/java和src/main/resources中的代码和配置文件编译到target/classes中，不会对src/test/java中的测试类进行编译
MVN编译使用
maven-resources-plugin:2.6:resources
maven-compiler-plugin:2.5.1:compile
&nbs
    

    • 

  • 【Java命令二】jhat
bit1129
Java命令

    jhat用于分析使用jmap dump的文件，，可以将堆中的对象以html的形式显示出来，包括对象的数量，大小等等，并支持对象查询语言。 jhat默认开启监听端口7000的HTTP服务，jhat是Java Heap Analysis Tool的缩写
1. 用法：
[hadoop@hadoop bin]$ jhat -help
Usage: jhat [-stack <bool&g
    

    • 

  • JBoss 5.1.0 GA:Error installing to Instantiated: name=AttachmentStore state=Desc
ronin47

    进到类似目录 server/default/conf/bootstrap，打开文件 profile.xml找到： Xml代码<bean 
 
name="AttachmentStore" 
class="org.jboss.system.server.profileservice.repository.AbstractAtta
    

    • 

  • 写给初学者的6条网页设计安全配色指南
brotherlamp
UIui自学ui视频ui教程ui资料

    网页设计中最基本的原则之一是，不管你花多长时间创造一个华丽的设计，其最终的角色都是这场秀中真正的明星——内容的衬托
    我仍然清楚地记得我最早的一次美术课，那时我还是一个小小的、对凡事都充满渴望的孩子，我摆放出一大堆漂亮的彩色颜料。我仍然记得当我第一次看到原色与另一种颜色混合变成第二种颜色时的那种兴奋，并且我想，既然两种颜色能创造出一种全新的美丽色彩，那所有颜色
    

    • 

  • 有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。写一个函数实现。复杂度是什么。
bylijinnan
java算法面试

    
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
/**
* http://weibo.com/1915548291/z7HtOF4sx
* #面试题#有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。
* 写一个函数实现。复杂度是什么
    

    • 

  • struts2获得request、session、application方式
chiangfai
application

    1、与Servlet API解耦的访问方式。
a.Struts2对HttpServletRequest、HttpSession、ServletContext进行了封装，构造了三个Map对象来替代这三种对象要获取这三个Map对象，使用ActionContext类。
----->
 
package pro.action;
import java.util.Map;
imp
    

    • 

  • 改变python的默认语言设置
chenchao051
python

     import sys
sys.getdefaultencoding()
 可以测试出默认语言，要改变的话，需要在python lib的site-packages文件夹下新建：
sitecustomize.py， 这个文件比较特殊，会在python启动时来加载，所以就可以在里面写上：
import sys
sys.setdefaultencoding('utf-8')
&n
    

    • 

  • mysql导入数据load data infile用法
daizj
mysql导入数据

    我们常常导入数据！mysql有一个高效导入方法，那就是load data infile 下面来看案例说明
基本语法：
load data  [low_priority] [local] infile 'file_name txt' [replace | ignore]
into table tbl_name
[fields
[terminated by't']
[OPTI
    

    • 

  • phpexcel导入excel表到数据库简单入门示例
dcj3sjt126com
PHPExcel

    
跟导出相对应的，同一个数据表，也是将phpexcel类放在class目录下，将Excel表格中的内容读取出来放到数据库中
<?php
error_reporting(E_ALL);
set_time_limit(0);
?>
<html>
<head>
<meta http-equiv="Content-Type" 
    

    • 

  • 22岁到72岁的男人对女人的要求
dcj3sjt126com

    22岁男人对女人的要求是：一，美丽，二，性感，三，有份具品味的职业，四，极有耐性，善解人意，五，该聪明的时候聪明，六，作小鸟依人状时尽量自然，七，怎样穿都好看，八，懂得适当地撒娇，九，虽作惊喜反应，但看起来自然，十，上了床就是个无条件荡妇。 32岁的男人对女人的要求，略作修定，是：一，入得厨房，进得睡房，二，不必服侍皇太后，三，不介意浪漫蜡烛配盒饭，四，听多过说，五，不再傻笑，六，懂得独
    

    • 

  • Spring和HIbernate对DDM设计的支持
e200702084
DAO设计模式springHibernate领域模型

    A：数据访问对象
    DAO和资源库在领域驱动设计中都很重要。DAO是关系型数据库和应用之间的契约。它封装了Web应用中的数据库CRUD操作细节。另一方面，资源库是一个独立的抽象，它与DAO进行交互，并提供到领域模型的“业务接口”。
   资源库使用领域的通用语言，处理所有必要的DAO，并使用领域理解的语言提供对领域模型的数据访问服务。
    

    • 

  • NoSql 数据库的特性比较
geeksun
NoSQL

    Redis 是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。目前由VMware主持开发工作。
 
1. 数据模型
作为Key-value型数据库，Redis也提供了键（Key）和值（Value）的映射关系。除了常规的数值或字符串，Redis的键值还可以是以下形式之一：
Lists （列表）
Sets
    

    • 

  • 使用 Nginx Upload Module 实现上传文件功能
hongtoushizi
nginx

    转载自： http://www.tuicool.com/wx/aUrAzm
 
普通网站在实现文件上传功能的时候，一般是使用Python，Java等后端程序实现，比较麻烦。Nginx有一个Upload模块，可以非常简单的实现文件上传功能。此模块的原理是先把用户上传的文件保存到临时文件，然后在交由后台页面处理，并且把文件的原名，上传后的名称，文件类型，文件大小set到页面。下
    

    • 

  • spring-boot-web-ui及thymeleaf基本使用
jishiweili
springthymeleaf

    视图控制层代码demo如下：
 
@Controller
@RequestMapping("/")
public class MessageController {
private final MessageRepository messageRepository;
@Autowired
public MessageController(Mes
    

    • 

  • 数据源架构模式之活动记录
home198979
PHP架构活动记录数据映射

    hello!架构
一、概念
活动记录（Active Record）：一个对象，它包装数据库表或视图中某一行，封装数据库访问，并在这些数据上增加了领域逻辑。
对象既有数据又有行为。活动记录使用直截了当的方法，把数据访问逻辑置于领域对象中。
 
二、实现简单活动记录
活动记录在php许多框架中都有应用，如cakephp。
<?php
/**
* 行数据入口类
*
    

    • 

  • Linux Shell脚本之自动修改IP
pda158
linuxcentosDebian脚本

    作为一名
Linux SA，日常运维中很多地方都会用到脚本，而服务器的ip一般采用静态ip或者MAC绑定，当然后者比较操作起来相对繁琐，而前者我们可以设置主机名、ip信息、网关等配置。修改成特定的主机名在维护和管理方面也比较方便。如下脚本用途为：修改ip和主机名等相关信息，可以根据实际需求修改，举一反三！
#!/bin/sh
#auto Change ip netmask ga
    

    • 

  • 开发环境搭建
独浮云
eclipsejdktomcat

           最近在开发过程中，经常出现MyEclipse内存溢出等错误，需要重启的情况，好麻烦。对于一般的JAVA+TOMCAT项目开发，其实没有必要使用重量级的MyEclipse，使用eclipse就足够了。尤其是开发机器硬件配置一般的人。
 
      &n
    

    • 

  • 操作日期和时间的工具类
vipbooks
工具类

       大家好啊，好久没有来这里发文章了，今天来逛逛，分享一篇刚写不久的操作日期和时间的工具类，希望对大家有所帮助。
/*
* @(#)DataFormatUtils.java 2010-10-10
*
* Copyright 2010 BianJing,All rights reserved.
*/
package test;
impor
    

    •