java 多线程的意义 java多线程有什么好处

在我们的日常学习当中会发现java的知识点是总是息息相关的，可以串联起来。java中多线程的有关内容可以衍生出更多知识，它的优缺点也是非常明显的。你都了解吗?一起来看看吧。

首先为大家介绍一下，多线程(多个线程同时运行)程序的优缺点

优点：

⑴可以减轻系统性能方面的瓶颈，因为可以并行操作;

⑵提高CPU的处理器的效率，在多线程中，通过优先级管理，可以使重要的程序优先操作，提高了任务管理的灵活性;

另一方面，在多CPU系统中，可以把不同的线程在不同的CPU中执行，真正做到同时处理多任务。

缺点：

⑴开启线程需要占用一定的内存空间(默认情况下，主线程占用1M，子线程占用512KB)，如果开启大量的线程，会占用大量的内存空间，降低程序的性能

⑵线程越多，CPU在调度线程上的开销就越大

⑶程序设计更加复杂：比如线程之间的通信、多线程的数据共享

然后为大家展示一下同步的实例代码：Demo1:

package test.thread;
class SynTest
{
//非同步
static void method(Thread thread)
{
System.out.println("begin " + thread.getName());
try
{
Thread.sleep(2000);
}
catch (Exception ex)
{
ex.printStackTrace();
}
System.out.println("end " + thread.getName());
}
//同步方式一：同步方法
synchronized static void method1(Thread thread)
{ //这个方法是同步的方法，每次只有一
个线程可以进来
System.out.println("begin " + thread.getName());
try
{
Thread.sleep(2000);
}
catch (Exception ex)
{
ex.printStackTrace();
}
System.out.println("end " + thread.getName());
}
//同步方式二：同步代码块
static void method2(Thread thread)
{
synchronized(SynTest.class)
{
System.out.println("begin " + thread.getName());
try
{
Thread.sleep(2000);
}
catch (Exception ex)
{
ex.printStackTrace();
}
System.out.println("end " + thread.getName());
}
}
//同步方式三：使用同步对象锁
private static Object _lock1 = new Object();
private static byte _lock2[] = {}; //据说，此锁更可提高性能。源于：锁的对象越小越好
static void method3(Thread thread)
{
synchronized(_lock1)
{
System.out.println("begin " + thread.getName());
try
{
Thread.sleep(2000);
}
catch (Exception ex)
{
ex.printStackTrace();
}
System.out.println("end " + thread.getName());
}
}
public static void main(String[] args)
{
//启动3个线程，这里用了匿名类
for (int i = 0; i 
{
new Thread()
{
public void run()
{
method(this);
//method1(this);
//method2(this);
//method3(this);
}
}.start();
}
}
}
Demo2:
package test.thread;
import com.util.LogUtil;
public class SynTest2
{
public static void main(String[] args)
{
Callme target = new Callme();
Caller ob1 = new Caller(target, "Hello");
Caller ob2 = new Caller(target, "Synchronized");
Caller ob3 = new Caller(target, "World");
}
}
class Callme
{
synchronized void test()
{
LogUtil.log("测试是否是：一旦一个线程进入一个实例的任何同步方法，别的线程将不能
进入该同一实例的其它同步方法， 但是该实例的非同步方法仍然能够被调用 ");
}
void nonsynCall(String msg)
{
LogUtil.log("[" + msg);
LogUtil.log("]");
}
synchronized void synCall(String msg)
{
LogUtil.logPrint("[" + msg);
LogUtil.log("]");
}
}
class Caller implements Runnable
{
String msg;
Callme target;
Thread t;
Caller(Callme target, String msg)
{
this.target = target;
this.msg = msg;
t = new Thread(this);
t.start();
}
public void run()
{
// TODO Auto-generated method stub
//target.nonsynCall(msg);
target.synCall(msg);
target.test();
}
}

同步的实例代码还是非常详细的，这也是与线程有关的比较繁琐的知识点。