⑴ 什么是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多线程并发的问题
回答这个问题需要先弄清楚线程的概念和线程的生命周期。
线程：是指程序代码的一次执行，是动态的过程。楼主在定义OneTh这个实现Runnable接口类的时候肯定复写了他的run()方法。onet1和onet2是两个线程，也就是说虽然他们的run()方法相同，但是是执行了两次的。
计算机中CPU的调度过程：现在的电脑看上去能同时实现多任务，像是一边上QQ，一边听音乐，还可以一边上网。但计算机中的CPU只有一个，它没有分身术，不可能真正意义上实现同时运行这么多程序。而是采用了一种时间片轮转的方式，为每个应用程序赋予极短的时间，然后高速的在不同的程序间切换，至于每次切换到那个程序，这个要由CPU和线程的优先级来决定。
线程的生命周期：创建时是初始化了这个线程，调用start方法时，是让这个线程进入了可运行状态，注意是可运行，不是正在运行。就像上面说的，在某一时刻CPU具体要运行谁是由CPU和线程的优先级决定的。当线程被CPU运行时，就会开始执行run方法，但可能执行到一半时，CPU又被其他可运行线程抢走，而只能暂停执行。
JAVA程序线程的运行:在我们使用java命令来运行程序时，这时候已经开始了两个线程，一个是main()方法的线程，一个是垃圾回收的线程。当楼主调用start方法开启另外两个线程时。这时候由于CPU来决定运行哪个线程。所以虽然noet1是先开启的，但在执行noet1时，CPU可能又去跑去执行main线程了，然后就会开启onet2.
还有我觉得主线程结束了，只不过其他两个线程仍在继续运行。所以会打印出结果。
楼主如果还有什么不明白的话可以继续问或者相互讨论。
⑶ java多线程是怎么回事
进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。
线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。
Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。
Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。
class ThreadTest{
public static void main(String args[]){
Thread t = Thread.currentThread();
t.setName("单线程"); //对线程取名为"单线程"
t.setPriority(8);
//设置线程优先级为8，最高为10，最低为1，默认为5
System.out.println("The running thread: " + t);
// 显示线程信息
try{
for(int i=0;i<3;i++){
System.out.println("Sleep time " + i);
Thread.sleep(100); // 睡眠100毫秒
}
}catch(InterruptedException e){// 捕获异常
System.out.println("thread has wrong");
}
}
}
多线程的实现方法
继承Thread类
可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。
在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为:
public class ThreadSubclassName extends Thread{
public ThreadSubclassName(){
..... // 编写子类的构造方法，可缺省
}
public void run(){
..... // 编写自己的线程代码
}
}
用定义的线程子类ThreadSubclassName创建线程对象的一般格式为:
ThreadSubclassName ThreadObject =
new ThreadSubclassName();
然后，就可启动该线程对象表示的线程：
ThreadObject.start(); //启动线程
应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。
class ThreadDemo extends Thread{
private String whoami;
private int delay;
public ThreadDemo(String s,int d){
whoami=s;
delay=d;
}
public void run(){
try{
sleep(delay);
}catch(InterruptedException e){ }
System.out.println("Hello World!" + whoami
+ " " + delay);
}
}
public class MultiThread{
public static void main(String args[]){
ThreadDemo t1,t2,t3;
t1 = new ThreadDemo("Thread1",
(int)(Math.random()*2000));
t2 = new ThreadDemo("Thread2",
(int)(Math.random()*2000));
t3 = new ThreadDemo("Thread3",
(int)(Math.random()*2000));
t1.start();
t2.start();
t3.start();
}
}
实现Runnable接口
编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。
创建线程对象可用下面的两个步骤来完成:
(1)生成Runnable类ClassName的对象
ClassName RunnableObject = new ClassName();
(2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。
Thread ThreadObject = new Thread(RunnableObject);
然后，就可启动线程对象ThreadObject表示的线程：
ThreadObject.start();
在Thread类中带有Runnable接口的构造方法有:
public Thread(Runnable target);
public Thread(Runnable target, String name);
public Thread(String name);
public Thread(ThreadGroup group，Runnable target);
public Thread(ThreadGroup group，Runnable target，
String name);
其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。
用Runnable接口实现的多线程。
class TwoThread implements Runnable{
TwoThread(){
Thread t1 = Thread.currentThread();
t1.setName("第一主线程");
System.out.println("正在运行的线程: " + t1);
Thread t2 = new Thread(this,"第二线程");
System.out.println("创建第二线程");
t2.start();
try{
System.out.println("第一线程休眠");
Thread.sleep(3000);
}catch(InterruptedException e){
System.out.println("第一线程有错");
}
System.out.println("第一线程退出");
}
public void run(){
try{
for(int i = 0;i < 5;i++){
System.out.println(“第二线程的休眠时间：”
+ i);
Thread.sleep(1000);
}
}catch(InterruptedException e){
System.out.println("线程有错");
}
System.out.println("第二线程退出");
}
public static void main(String args[]){
new TwoThread();
}
}
程序运行结果如下：
正在运行的线程: Thread[第一主线程,5,main
创建第二线程
第一线程休眠
第二线程的休眠时间：0
第二线程的休眠时间：1
第二线程的休眠时间：2
第一线程退出
第二线程的休眠时间：3
第二线程的休眠时间：4
第二线程退出
⑷ JAVA的多线程问题
两个建议，
尝试一下synchornized
来个例子你实验下
public class SyncDemo {
public static void main(String[] args) {
final Aoo ao=new Aoo();
Thread t=new Thread() {
public void run() {
ao.mathodA();
}
};
Thread t1=new Thread() {
public void run() {
ao.mathodB();
}
};
t.start();
t1.start();
}
}
class Aoo{
public synchronized void mathodA() {
try {
Thread t = Thread.currentThread();
System.out.println(t.getName()+"正在执行A方法...");
Thread.sleep(5000);
;
System.out.println("A方法执行完毕");
} catch (Exception e) {
}
}
public synchronized void mathodB(){
try {
Thread t = Thread.currentThread();
System.out.println(t.getName()+"正在执行B方法");
Thread.sleep(5000);
System.out.println("B方法执行完毕");
} catch (Exception e) {
}
}
}
2.线程池，限制一次运行的线程数量。
不过哥们你这个需求就别用线程了呗，本来线程就是并发的 你在费个周折弄回去 不用不就好了？
⑸ 怎么处理JAVA多线程死锁问题
有两种实现方法，分别是继承Thread类与实现Runnable
接口
用synchronized关键字修饰同步方法
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么
其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用
suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定
的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个
锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该
活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个
notify()重新启动线程。
⑹ java多线程并发问题怎么解决
java多线程并发问题产生的主要原因是多个线程访问一个实例，导致其中一个线程修改或删除这个实例时，其他线程产生并发问题。
要解决这种并发问题有两种方法：
（1）加上线程锁synchronization
（2）还有个不是办法的办法：不用成员变量，用局部变量