多线程会产生哪些并发问题（java多线程并发问题怎么解决）

本文目录

• java多线程并发问题怎么解决
• J**A多线程并发问题
• 多线程并发会造成程序周期性崩溃吗
• 多线程并发执行中的问题
• C#多线程中经常访问同一资源可能造成什么问题该怎么解决
• java多线程并发去调用一个类的静态方法，有什么问题
• java多线程访问同一个数组，存在并发问题吗，每个线程访问的是数组的不同部分，不存在冲突
• java多线程并发的问题
• 多线程并发的注意点

java多线程并发问题怎么解决

java多线程并发问题产生的主要原因是多个线程访问一个实例，导致其中一个线程修改或删除这个实例时，其他线程产生并发问题。
要解决这种并发问题有两种方法：
（1）加上线程锁synchronization
（2）还有个不是办法的办法：不用成员变量，用局部变量

J**A多线程并发问题

看你的描述，你是使用了类的成员变量，也就是static的静态变量是吧，你得这种情况最好的解决办法就是不用静态变量，改用实例成员变量，这样每一个对象各自都有各自的变量。当然如果你一定要用静态变量，那么你得程序就牵扯到线程安全问题了，你得多个线程，在争夺共有的资源（类静态变量）要么改成单线程，要么变成同步语句块或者同步方法，保证共有资源的锁定和可靠性。

多线程并发会造成程序周期性崩溃吗

只有线程处理出错才会造成奔溃，简单举个例子，线程刷新控件，你用整个父容器去invork，invork有Begin和end，前提条件还需要你已经创建了句柄，当窗体启动后，系统还会在后台启动窗体重绘，这时候线程开启了子线程，如果他快过主线程启动，那么它就会报从不创建句柄的控件更新ui错误，你不抛出强行执行，就会造成系统奔溃。所以控件少用invork，传值用传值对象去Post，界面使用传值方法，回调你要做接口。另一个典型的错误来自于，你创建了N个子线程，你不确定它到底有没有全部完成，主线程干掉了，对不起，子线程还没完呢？你都不处理一下，也不abort也不kill，程序就会溢出奔溃......周期性奔溃你用计时器，子线程没有闭环，直接new一个对象然后直接start，就没有处理abort机制，它能不奔溃吗？有些ui刷新动作，你不注意句柄和控件和容器的关系，它绝对也是要奔溃的。

多线程并发执行中的问题

多个线程相对执行的顺序是不确定的。
�8�4线程执行顺序的不确定性会产生执行结果的不确定性。
�8�4在多线程对共享数据 操作时常常会产生这种不确定性

C#多线程中经常访问同一资源可能造成什么问题该怎么解决

竞态条件和死锁。
如果两个或多个线程访问相同的对象，或者访问不同步的共享状态 ，就会出现竞态条件。为了避免出现该问题，可以锁定共享的对象。但是过多的锁定也会有麻烦，那就是死锁。当至少有两个线程被挂起，等待对方解除锁定。由于两个线程都在等待对方，就出现了死锁，线程将无限等下去。
要避免同步问题，最好不要在线程之间共享数据。当然，这并不总是可行的。如果需要共享数据
，就必须使用同步技术，确保一次只有一个线程访问和改变共享状态。注意，同步问题与竞态条件和死锁有关。如果不注意这些问题，就很难在应用程序中找到问题的原因，因为线程问题是不定期发生的。
你还是好好的去看看这方面的书吧。《C#高级编程》之类的书里都讲的比较详细。。。。

java多线程并发去调用一个类的静态方法，有什么问题

总的结论：java是线程安全的，即对任何方法（包括静态方法）都可以不考虑线程冲突，但有一个前提，就是不能存在全局变量。如果存在全局变量，则需要使用同步机制。
如下通过一组对比例子从头讲解：
在多线程中使用静态方**发生什么事？也就是说多线程访问同一个类的static静态方**发生什么事？是否会发生线程安全问题？
public class Test {
public static void operation(){
// ... do something
}
}
事实证明只要在静态函数中没有处理多线程共享数据，就不存在着多线程访问同一个静态方**出现资源冲突的问题。下面看一个例子：
public class StaticThread implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
StaticAction.print();
}
public static void main(String args) {
for (int i = 0; i 《 100; i++) {
new Thread(new StaticThread()).start();
}
}
}
public class StaticAction {
public static int i = 0;
public static void print() {
int sum = 0;
for (int i = 0; i 《 10; i++) {
System.out.print("step " + i + " is running.");
sum += i;
}
if (sum != 45) {
System.out.println("Thread error!");
System.exit(0);
}
System.out.println("sum is " + sum);
}
}
实际执行的结果显示各个线程对静态方法的访问是交叉执行的，但是这并不影响各个线程静态方法print()中sum值的计算。也就是说，在此过程中没有使用全局变量的静态方法在多线程中是安全的，静态方法是否引起线程安全问题主要看该静态方法是否对全局变量（静态变量static member）进行修改操作。
在多线程中使用同一个静态方法时，每个线程使用各自的实例字段(instance field)的副本，而共享一个静态字段(static field)。所以说，如果该静态方法不**作一个静态成员，只在方法内部使用实例字段(instance field)，不会引起安全性问题。
但是，如果该静态方法操作了一个静态变量，则需要静态方法中采用互斥访问的方式进行安全处理。我们来看一下没有使用互斥访问的话会产生怎样的问题：public class StaticAction {
public static int i = 0;
public static void incValue() {
int temp = StaticAction.i;
try {
Thread.sleep(1);
} catch (Exception e) {
e.printStackTrace();
}
temp++;
StaticAction.i = temp;
}
}
public class StaticThread implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
StaticAction.incValue();
}
public static void main(String args) {
for (int i = 0; i 《 100; i++) {
new Thread(new StaticThread()).start();
}
try {
Thread.sleep(1000); //预留足够的时间让上面的线程跑完
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(StaticAction.i);
}
}
实际运行结果显示i值为随机的数字。为了实现互斥访问，这时我们需要加入一个synchronized关键字。代码修改如下：
public class StaticAction {
public static int i = 0;
public synchronized static void incValue() {
int temp = StaticAction.i;
try {
Thread.sleep(1);
} catch (Exception e) {
e.printStackTrace();
}
temp++;
StaticAction.i = temp;
}
}
public class StaticThread implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
StaticAction.incValue();
}
public static void main(String args) {
for (int i = 0; i 《 100; i++) {
new Thread(new StaticThread()).start();
}
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(StaticAction.i);
}
}
运行结果则必然是100。
加入synchronized关键字的静态方法称为同步静态方法。
在访问同步静态方法时，会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。这个其实就是操作系统中的用信号量实现进程的互斥与同步问题，如果涉及在同一个类中有多个静态方法中处理多线程共享数据的话，那就变成用信号量解决生产者-消费者问题。也就是说，静态方法是一份临界资源，对静态方法的访问属于进入临界区；对静态变量的修改是一份临界资源，对静态变量的修改属于进入临界区。

java多线程访问同一个数组，存在并发问题吗，每个线程访问的是数组的不同部分，不存在冲突

多线程访问同一资源肯定存在并发问题，如数据丢失。
如果，每个线程访问不同部分，不会存在冲突问题。
冲突问题，归根结底是，多线程对同一资源的操作，资源你可以想象成一个对象、一个文件等等
在处理此问题时，可以使用同步，来保证线程安全

java多线程并发的问题

回答这个问题需要先弄清楚线程的概念和线程的生命周期。

线程：是指程序代码的一次执行，是动态的过程。楼主在定义OneTh这个实现Runnable接口类的时候肯定复写了他的run()方法。onet1和onet2是两个线程，也就是说虽然他们的run()方法相同，但是是执行了两次的。

计算机中CPU的调度过程：现在的电脑看上去能同时实现多任务，像是一边上QQ，一边听音乐，还可以一边上网。但计算机中的CPU只有一个，它没有分身术，不可能真正意义上实现同时运行这么多程序。而是采用了一种时间片轮转的方式，为每个应用程序赋予极短的时间，然后高速的在不同的程序间切换，至于每次切换到那个程序，这个要由CPU和线程的优先级来决定。

线程的生命周期：创建时是初始化了这个线程，调用start方法时，是让这个线程进入了可运行状态，注意是可运行，不是正在运行。就像上面说的，在某一时刻CPU具体要运行谁是由CPU和线程的优先级决定的。当线程被CPU运行时，就会开始执行run方法，但可能执行到一半时，CPU又被其他可运行线程抢走，而只能暂停执行。

J**A程序线程的运行:在我们使用java命令来运行程序时，这时候已经开始了两个线程，一个是main()方法的线程，一个是垃圾回收的线程。当楼主调用start方法开启另外两个线程时。这时候由于CPU来决定运行哪个线程。所以虽然noet1是先开启的，但在执行noet1时，CPU可能又去跑去执行main线程了，然后就会开启onet2.

还有我觉得主线程结束了，只不过其他两个线程仍在继续运行。所以会打印出结果。

楼主如果还有什么不明白的话可以继续问或者相互讨论。

多线程并发的注意点

首先说下进程和线程的区别：

1.进程是内存中运行的应用程序，每个进程有一个独立的内存空间。一个应用程序可以有多个进程。线程是进程中的一个执行单元。一个进程中可以有多个线程。

2.多线程并发从微观角度也是有先后顺序的，哪个线程先执行取决于cpu调度。每个java进程至少有两个线程，main线程和垃圾回收线程。创建一个线程开销比进程小的多。

3.线程的作用就是去执行一段代码。

多线程并发的注意点：

多线程并发运行中，应该在保证线程运行安全的情况下，尽量少使用线程同步锁，因为线程同步对多线程并发运行的性能影响很大，比如日志输出可以不要求实时同步，那么就可以把线程同步输出日志改为异步输出。

如果一定要使用线程同步锁，那么应该尽量减少线程同步的代码范围，只对必须保证线程安全的代码加线程同步锁。