java多线程问题
Ⅰ 一个关于java多线程的问题
javadoc THREAD
t.start();
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
结果是两个线程并发地运行；当前线程（从调用返回给 start 方法）和另一个线程（执行其 run 方法）。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
t.run();
如果该线程是使用独立的Runnable运行构造的，则调用该Runnable对象的run方法。如果这个类是一个线程类，只要启动线程，就会执行run()方法。
说白了就是run直接调用接口的run方法
而start是调用两次，start的线程和run方法的线程！
Ⅱ 什么是Java多线程
多线程的概念？
说起多线程，那么就不得不说什么是线程，而说起线程，又不得不说什么是进程。
进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
进程可以简单的理解为一个可以独立运行的程序单位。它是线程的集合，进程就是有一个或多个线程构成的，每一个线程都是进程中的一条执行路径。
那么多线程就很容易理解：多线程就是指一个进程中同时有多个执行路径（线程）正在执行。
为什么要使用多线程？
1.在一个程序中，有很多的操作是非常耗时的，如数据库读写操作，IO操作等，如果使用单线程，那么程序就必须等待这些操作执行完成之后才能执行其他操作。使用多线程，可以在将耗时任务放在后台继续执行的同时，同时执行其他操作。
2.可以提高程序的效率。
3.在一些等待的任务上，如用户输入，文件读取等，多线程就非常有用了。
缺点：
1.使用太多线程，是很耗系统资源，因为线程需要开辟内存。更多线程需要更多内存。
2.影响系统性能，因为操作系统需要在线程之间来回切换。
3.需要考虑线程操作对程序的影响，如线程挂起，中止等操作对程序的影响。
4.线程使用不当会发生很多问题。
总结：多线程是异步的，但这不代表多线程真的是几个线程是在同时进行，实际上是系统不断地在各个线程之间来回的切换（因为系统切换的速度非常的快，所以给我们在同时运行的错觉）。
2.多线程与高并发的联系。
高并发：高并发指的是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况，主要发生在web系统集中大量访问或者socket端口集中性收到大量请求（例如：12306的抢票情况；天猫双十一活动）。该情况的发生会导致系统在这段时间内执行大量操作，例如对资源的请求，数据库的操作等。如果高并发处理不好，不仅仅降低了用户的体验度（请求响应时间过长），同时可能导致系统宕机，严重的甚至导致OOM异常，系统停止工作等。如果要想系统能够适应高并发状态，则需要从各个方面进行系统优化，包括，硬件、网络、系统架构、开发语言的选取、数据结构的运用、算法优化、数据库优化……。
而多线程只是在同/异步角度上解决高并发问题的其中的一个方法手段，是在同一时刻利用计算机闲置资源的一种方式。
多线程在高并发问题中的作用就是充分利用计算机资源，使计算机的资源在每一时刻都能达到最大的利用率，不至于浪费计算机资源使其闲置。
3.线程的创建，停止，常用方法介绍。
1.线程的创建：
线程创建主要有2种方式，一种是继承Thread类，重写run方法即可；（Thread类实现了Runable接口）
另一种则是实现Runable接口，也需要重写run方法。
线程的启动，调用start（）方法即可。 我们也可以直接使用线程对象的run方法，不过直接使用，run方法就只是一个普通的方法了。
其他的还有： 通过匿名内部类的方法创建；实现Callable接口。。。。。
2.线程常用方法：
currentThread()方法：该方法返回当前线程的信息 .getName（）可以返回线程名称。
isAlive()方法：该方法判断当前线程是否处于活动状态。
sleep()方法：该方法是让“当前正在执行的线程“休眠指定的时间，正在执行的线程是指this.currentThread()返回的线程。
getId()方法：该方法是获取线程的唯一标识。
3.线程的停止：
在java中，停止线程并不简单，不想for。。break那样说停就停，需要一定的技巧。
线程的停止有3种方法：
1.线程正常终止，即run()方法运行结束正常停止。
2.使用interrupt方法中断线程。
3.使用stop方法暴力停止线程。
interrupt方法中断线程介绍：
interrupt方法其实并不是直接中断线程，只是给线程添加一个中断标志。
判断线程是否是停止状态：
this.interrupted(); 判断当前线程是否已经中断。（判断的是这个方法所在的代码对应的线程，而不是调用对象对应的线程）
this.isInterrupted(); 判断线程是否已经中断。（谁调用，判断谁）
注：.interrupted()与isInterrupted()的区别：
interrupted()方法判断的是所在代码对应的线程是否中断，而后者判断的是调用对象对应的线程是否停止
前者执行后有清除状态的功能（如连续调用两次时，第一次返回true，则第二次会返回false）
后者没有清除状态的功能（两次返回都为true）
真正停止线程的方法：
异常法：
在run方法中 使用 this.interrupted();判断线程终止状态，如果为true则 throw new interruptedException()然后捕获该异常即可停止线程。
return停止线程：
在run方法中 使用 this.interrupted();判断线程终止状态，如果为true则return停止线程。 （建议使用异常法停止线程，因为还可以在catch中使线程向上抛，让线程停止的事件得以传播）。
暴力法：
使用stop()方法强行停止线程（强烈不建议使用，会造成很多不可预估的后果，已经被标记为过时）
（使用stop方法会抛出 java.lang.ThreadDeath 异常，并且stop方法会释放锁，很容易造成数据不一致）
注：在休眠中停止线程：
在sleep状态下停止线程 会报异常，并且会清除线程状态值为false；
先停止后sleep，同样会报异常 sleep interrupted；
4.守护线程。
希望对您有所帮助！~
Ⅲ 如何解决java 多线程问题
Java线程同步需要我们不断的进行相关知识的学习，下面我们就来看看如何才能更好的在学习中掌握相关的知识讯息，来完善我们自身的编写手段。希望大家有所收获。 Java线程同步的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。 你可以调用 Thread 类的方法 getPriority（）和 setPriority（）来存取Java线程同步的优先级，线程的优先级界于1（MIN_PRIORITY）和10（MAX_PRIORITY）之间，缺省是5（NORM_PRIORITY）。 Java线程同步 由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。 由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。 1． synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：1. public synchronized void accessVal（int newVal）； synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的Java线程同步方能获得该锁，重新进入可执行状态。 这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。 在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。 synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run（）声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。 2． synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：1. synchronized（syncObject）2. {3. //允许访问控制的代码4. } synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。 Java线程同步的阻塞 为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个Java线程同步对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。 阻塞指的是暂停一个Java线程同步的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。
Ⅳ java多线程问题
这是因为你没有处理并发问题
先说下 num-- ，这个过程也是可以拆分的：
从内存中取出num的值
num - 1
将减1后的值重新赋值给num（即放回内存）
下面以一个例子说明，为什么有可能会出现多个100
因为你没有做同步，所以线程t1和t2可能在同一瞬间执行到num--处，假设这刚好是程序开始的时候num还等于100。然后来看刚刚拆解的num--的过程。
t1取出了num的值，t2也同时取出了num的值，因为是同时，所以他们取到的都是100。
然后System.out.println输出的 num--，所以会输出num当前的值（减1前的值），在t1和t2看来 num现在都是100，所以会输出2次100。
接下来t1执行减1操作，并将结果99赋值给num。同时t2也执行减1操作，并将结果99赋值给num。
最终，虽然t1和t2都执行了num--，但是最终num的值却是99，这与预期肯定是不一样的。
这也就是编程中要处理的多线程并发问题。
Ⅳ Java多线程问题
线程之间的上下文切换也是需要cpu时间的。
最主要的是，一般来说在多核cpu下，多线程的效率是比单线程的高，但是这个高是建立在利用了空闲的cpu，因为一般来说cpu使用率都不很高，你这个程序的话，cpu使用已经很高了，多线程并不能让你的效率变高，反而因为上下文切换导致变低，关键在于理解多线程一般为什么会使效率变高。
Ⅵ 关于java中多线程的问题的一点思考（什么情
1，理解正确，几个线程各子锁定自己的同步锁，当然是没有什么用。对于竞争资源，必须锁定同一个锁，你可以new 一个Object用于锁，也可以用class做锁，反正都要是同一个。
2，理解有偏差，其他线程也会被调度，不可能一个线程一直sleep，其他线程都不工作了，影响范围没有那么大，仅限于需要进入同一个同步锁的，它们进不了工作。
所谓占着茅坑不拉shi，就是这个状态了。
3，多线程的好处是充分利用CPU的资源，实现并发。例如你说的通讯，往往是花百分之几的时间CPU处理数据，剩下的绝大部分时间，都是在等待网络数据。使用多线程可以充分利用这段时间。
Ⅶ java 多线程问题
你的设计只是一个单例模式，但是也是有问题
public static Singleton getInstance() {
if(singleton == null)
return new Singleton(); //始终没有给singleton赋值啊
else
return singleton;
}
可以改为return singleton=new Singleton();
这样也有个问题 --（昨天有点事，没有说完！）如果一个线程判断singleton为null还没有来的及赋值就被暂停，刚好另一个线程也运行此处给singleton赋值了，等前一个线程开始执行时就会再赋值一次。应该在加一个synchronized（this）加锁！有点复杂，可以定义singleton 时赋值getInstance直接返回这个值就可以了.
关于多处理器的问题，我个人觉的应该是由操作系统来负责调度，我们不用去关心，所有的程序时运行在java虚拟机上的，我们只关心虚拟机就可以了。
如果运行在多服务器上，那就应该需要的多虚拟机的同步了......这个我也没有研究过，爱莫能助
请采纳。
Ⅷ 多线程java问题
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。实现Runnable接口比继承Thread类所具有的优势：1）：适合多个相同的程序代码的线程去处理同一个资源2）：可以避免java中的单继承的限制3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个jVM实习在就是在操作系统中启动了一个进程。
Ⅸ java多线程的问题
import java.util.concurrent.ArrayBlockingQueue;
public class ArrayBlockingQueueTest {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue(1000);
queue.put("123");
Object value = queue.take();
System.out.println(value);
}
}
你的这个问题，是大部分多线程程序都会遇到的问题，因为JDK类库的开发者已经为我们准备了很多“队列”。
你可以考虑“先进先出阻塞队列”。
ArrayBlockingQueue<E>
一个由数组支持的有界阻塞队列。此队列按FIFO（先进先出）原则对元素进行排序。队列的头部是在队列中存在时间最长的元素。队列的尾部是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。
这是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞；试图从空队列中提取元素将导致类似阻塞。
一些重要的方法：
boolean add(Ee) 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回true，如果此队列已满，则抛出IllegalStateException。
boolean offer(Ee) 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回true，如果此队列已满，则返回false。
boolean offer(Ee,longtimeout,TimeUnitunit) 将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。
void put(Ee) 将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间。
----
E remove() 获取并移除此队列的头。
E poll() 获取并移除此队列的头，如果此队列为空，则返回null。
E poll(longtimeout,TimeUnitunit) 获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
E take() 获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。