1、程序建立1000个线程，有可能造成系统创建大量线程而导致消耗完系统内存，还会增加创建和销毁线程上所花的时间以及系统资源的开销
2、在创建线程数多的情况下，可以考虑使用线程池
以下是Java自带的几种线程池：
(1)、newFixedThreadPool 创建一个指定工作线程数量的线程池。
每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。
(2)、newCachedThreadPool 创建一个可缓存的线程池。
这种类型的线程池特点是：
1）.工作线程的创建数量几乎没有限制（其实也有限制的，数目为Interger. MAX_VALUE）， 这样可灵活的往线程池中添加线程。
2）.如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间（默认为1分钟），则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
(3)、创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行（我觉得这点是它的特色）。
单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的 。
(4)、newScheduleThreadPool 创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。
3、示例代码
package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 1000; i++) {
cachedThreadPool.execute(new Runnable() {
public void run() {
//在这里执行你需要的功能
}
});
}
}
}
2.在java中怎样写个多线程并发多线程有两种形式，一种是直接让当前类继承 Thread 重写run方法来实现，另一种是使用 Runnable接口。推荐第二种方法。
例：
public class Counter {
public volatile static int count = 0;
public static void inc() {
//这里延迟1秒，使得结果明显
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
count++;
}
public static void main(String[] args) {
//同时启动1000个线程，去进行i++计算，看看实际结果
for (int i = 0; i
3.在java中怎样写个多线程并发多线程有两种形式，一种是直接让当前类继承 Thread 重写run方法来实现，另一种是使用 Runnable接口。
推荐第二种方法。 例： public class Counter { public volatile static int count = 0; public static void inc（) { //这里延迟1秒，使得结果明显 try { Thread.sleep(1000); } catch (InterruptedException e) { } count++; } public static void main(String[] args) { //同时启动1000个线程，去进行i++计算，看看实际结果 for (int i = 0; i < 1000; i++) { new Thread(new Runnable() { @Override public void run() { Counter.inc(); } }).start（)； } //这里每次运行的值都有可能不同，可能不为1000 System.out.println（"运行结果：Counter.count=" + Counter.count）; } }。
4.Java多线程的几种写法有三种：
(1)继承Thread类，重写run函数
创建：
class xx extends Thread{
public void run(){
Thread.sleep(1000) //线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源
}}
开启线程：
对象.start（) //启动线程，run函数运行
(2)实现Runnable接口，重写run函数
开启线程：
Thread t = new Thread（对象） //创建线程对象
t.start()
(3)实现Callable接口，重写call函数
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
Callable和Runnable有几点不同：
①Callable规定的方法是call（)，而Runnable规定的方法是run().
②Callable的任务执行后可返回值，而Runnable的任务是不能返回值的
③call（)方法可抛出异常，而run（)方法是不能抛出异常的。
④运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等
待计算的完成，并检索计算的结果.通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果
5.如何用Java编写多线程//两种方式
public class ThreadDemo extends Thread{
public void run(){
System.out.println（"线程"+Thread.currentThread().getName());
}
public static void main(String[] args){
ThreadDemo t1 = new ThreadDemo（)；//创建线程
t1.start（)；//启动线程
//创建第二个线程
ThreadDemo t2 = new ThreadDemo（)；//创建线程
t2.start（)；//启动线程
}
}//方式二，实现Runnable接口
public class ThreadDemo implements Runnable{
public void run(){
System.out.println（"线程"+Thread.currentThread().getName());
}
public static void main(String[] args){
//创建线程实例
ThreadDemo td = new ThreadDemo()
//创建线程1
Thread t1 = new Thread(td);
t1.start();
//创建线程2
Thread t2 = new Thread(td);
t2.start();
}
}
6.怎么设置1000线程在线程池 java如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue
class Digital{
private volatile int i =0;
private volatile long total =0;
private boolean completed = false;
public void increase(){
synchronized(this){
System.out.println(Thread.currentThread().getName()+" is increasing"）； //辅助观看结果的 ，可以注释掉
if(++i <= 1000)
total += i;
else{
this.completed = true;
this.notifyAll（)； //唤醒主线程
}
}
}
public long getTotal(){
return this.total;
}
public boolean isCompleted(){
return this.completed;
}
}
public class DigitalIncrease extends Thread {
Digital digital = null;
DigitalIncrease(Digital digtal){
this.digital = digtal;
start();
}
public void run(){
while(true){
if(digital.isCompleted())
break； //如果加法操作已经完成了 就退出线程
digital.increase();
}
}
public static void main(String [] args){
Digital digital = new Digital();
DigitalIncrease [] diArray = new DigitalIncrease[10];
for(int i = 0; i<10; i++){
diArray[i]= new DigitalIncrease(digital)； //创建10个线程
}
//如果加法没完成就让主线程等待
try {
synchronized (digital){
while(!digital.isCompleted())
digital.wait();
}
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(digital.getTotal());
}
}
