多个线程要操作同一资源时就有可能出现资源的同步问题。
同步就是指多个操作在同一个时间段内只能有一个线程进行，其他线程要等待此线程完成之后才可以继续执行。
解决资源共享的同步操作，可以使用同步代码块和同步方法两种方式完成。
<1>同步代码块
所谓代码块就是指使用“{}"括起来的一段代码，根据其位置和声明的不同，可以分为普通代码块、构造块、静态块3种，如果在代码块上加上synchronized关键字，则此代码块就称为同步代码块。
package java_thread;
//=================================================
// File Name : Runnable_demo2
//------------------------------------------------------------------------------
// Author : Common
// 类名：MyThread_2
// 属性：
// 方法：
class MyThread_2 implements Runnable{
private int ticket = 5;
@Override
public void run() { //覆写Thread类中的run()方法
// TODO 自动生成的方法存根
for (int i=0;i<10;i++){
synchronized (this) { //设置需要同步的操作
if(ticket>0){
try{
Thread.sleep(300);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println("卖票：ticket="+ticket--);
}
}
// this.sale(); //调用同步方法
}
}
}
//主类
//Function : Thread_demo2
public class Runnable_demo2 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
MyThread_2 mt = new MyThread_2(); //实例化Runnable子类对象
Thread t1 = new Thread(mt); //实例化Thread类对象
Thread t2 = new Thread(mt); //实例化Thread类对象
Thread t3 = new Thread(mt); //实例化Thread类对象
t1.start(); //启动线程
t2.start(); //启动线程
t3.start(); //启动线程
}
}
package java_thread;
class Output{
public void output(String name){
int len = name.length();
synchronized(this){ //不能使用name，因为“输出1”和"输出2"两个字符串不是同一个对象
for(int i=0;i<len;i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
public class Huchi {
private void init(){
final Output outputer = new Output();
//线程1
new Thread(new Runnable(){
@Override
public void run() { //覆写Thread类中的run()方法
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
//new Output().output("输出1"); //也不能new对象，new对象的话，this就不代表同一个对象了
outputer.output("输出1");
}
}
}).start();
//线程2
new Thread(new Runnable(){
@Override
public void run() { //覆写Thread类中的run()方法
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
//new Output().output("输出1"); //也不能new对象，new对象的话，this就不代表同一个对象了
outputer.output("输出2");
}
}
}).start();
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
new Huchi().init();
}
}
<2>同步方法
也可以使用synchronized关键字将一个方法声明成同步方法
//=================================================
// File Name : Thread_demo
//------------------------------------------------------------------------------
// Author : Common
// 接口名：MyThread
// 属性：
// 方法：
class MyThread_2 implements Runnable{
private int ticket = 5;
@Override
public void run() { //覆写Thread类中的run()方法
// TODO 自动生成的方法存根
for (int i=0;i<10;i++){
this.sale(); //调用同步方法
}
}
public synchronized void sale(){ //声明同步方法
if(ticket>0){
try{
Thread.sleep(300);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println("卖票：ticket="+ticket--);
}
}
}
//主类
//Function : Thread_demo2
public class Runnable_demo2 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
MyThread_2 mt = new MyThread_2(); //实例化Runnable子类对象
Thread t1 = new Thread(mt); //实例化Thread类对象
Thread t2 = new Thread(mt); //实例化Thread类对象
Thread t3 = new Thread(mt); //实例化Thread类对象
t1.start(); //启动线程
t2.start(); //启动线程
t3.start(); //启动线程
}
}
死锁就是指两个线程都在等待彼此先完成，造成了程序的停滞,一般程序的死锁都是在程序运行时出现的。
多个线程共享同一资源时需要进行同步，以保证资源操作的完整性，但是过多的同步就有可能产生死锁。
生产者不断生产，消费者不断取走生产者生产的产品
//=================================================
// File Name : ThreadInfo_demo
//------------------------------------------------------------------------------
// Author : Common
// 类名：Info
// 属性：
// 方法：
class Info{
private String name = "张三";
private String content = "学生";
private boolean flag = false;
public synchronized void set(String name,String content){ //设置信息名称及内容
if(!flag){ //标志位为false，不可以生产，在这里等待取走
try{
super.wait(); //等待消费者取走
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.setName(name); //设置信息名称
try{
Thread.sleep(300); //加入延迟
}catch(InterruptedException e){
e.printStackTrace();
}
this.setContent(content); //设置信息内容
flag = false; //标志位为true，表示可以取走
super.notify(); //唤醒等待线程
}
public synchronized void get(){ //取得信息内容
if(flag){ //标志位为true，不可以取走
try{
super.wait(); //等待生产者生产
}catch(InterruptedException e){
e.printStackTrace();
}
}
try {
Thread.sleep(300); //加入延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getName()+"-->"+this.getContent()); //输出信息
flag = true; //修改标志位为true，表示可以生产
super.notify(); //唤醒等待线程
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
//类名：Producer
//属性：
//方法：
class Producer implements Runnable{ //定义生产者线程
private Info info = null; //保存Info引用
public Producer(Info info) { //构造函数
super();
this.info = info;
}
@Override
public void run() {
// TODO 自动生成的方法存根
boolean flag = false;
for(int i=0;i<50;i++){ //50次反复修改name和content的值
if(flag){
this.info.set("张三", "学生");
flag = false;
}else{
this.info.set("李四", "老师");
flag = true;
}
}
}
}
//类名：Consumer
//属性：
//方法：
class Consumer implements Runnable{ //定义生产者线程
private Info info = null; //保存Info引用
public Consumer(Info info) { //构造函数
super();
this.info = info;
}
@Override
public void run() {
// TODO 自动生成的方法存根
for(int i=0;i<50;i++){ //50次反复修改name和content的值
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.info.get();
}
}
}
//主类
//Function : ThreadInfo_demo
public class ThreadInfo_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Info i = new Info();
Producer pro = new Producer(i);
Consumer con = new Consumer(i);
new Thread(pro).start();
new Thread(con).start();
}
}
停止线程运行
在多线程的开发中可以通过设置标志位的方式停止一个线程的运行
//=================================================
// File Name : ThreadInfo_demo
//------------------------------------------------------------------------------
// Author : Common
// 类名：MYThread
// 属性：
// 方法：
class MYThread implements Runnable{
private boolean flag = true; //定义标志位属性
@Override
public void run() {
// TODO 自动生成的方法存根
int i = 0;
while(this.flag){ //循环输出
while(true){
System.out.println(Thread.currentThread().getName()+(i++)); //输出当前线程名称
}
}
}
public void stop(){ //编写停止方法
this.flag = false; //修改标志位
}
}
//主类
//Function : ThreadStop_demo
public class ThreadStop_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
MYThread my = new MYThread();
Thread t = new Thread(my,"线程");
t.start();
my.stop();
}
}
互斥性
output1和output2两段代码互斥，检查的都是outputer这个对象
package java_thread;
class Output{
public void output(String name){
int len = name.length();
synchronized(this){ //不能使用name，因为“输出1”和"输出2"两个字符串不是同一个对象
for(int i=0;i<len;i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}
public synchronized void output2(String name){ //output1和output2两段代码互斥，检查的都是outputer这个对象
int len = name.length();
for(int i=0;i<len;i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}
public class Huchi {
private void init(){
final Output outputer = new Output();
//线程1
new Thread(new Runnable(){
@Override
public void run() { //覆写Thread类中的run()方法
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
//new Output().output("输出1"); //也不能new对象，new对象的话，this就不代表同一个对象了
outputer.output("输出1");
}
}
}).start();
//线程2
new Thread(new Runnable(){
@Override
public void run() { //覆写Thread类中的run()方法
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
//new Output().output("输出1"); //也不能new对象，new对象的话，this就不代表同一个对象了
outputer.output2("输出2");
}
}
}).start();
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
new Huchi().init();
}
}
static静态方法调用的对象是字节码对象，所以要把output1的this改成Output.class
package java_thread;
class Output{
public void output1(String name){
int len = name.length();
synchronized(this){ //不能使用name，因为“输出1”和"输出2"两个字符串不是同一个对象
for(int i=0;i<len;i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}
//static静态方法调用的对象是字节码对象，所以要把output1的this改成Output.class
public static synchronized void output3(String name){ //output1和output3不同步，除非把output1的this改成Output.class
int len = name.length();
for(int i=0;i<len;i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}
public class Huchi {
private void init(){
final Output outputer = new Output();
//线程1
new Thread(new Runnable(){
@Override
public void run() { //覆写Thread类中的run()方法
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
//new Output().output("输出1"); //也不能new对象，new对象的话，this就不代表同一个对象了
outputer.output1("输出1");
}
}
}).start();
//线程2
new Thread(new Runnable(){
@Override
public void run() { //覆写Thread类中的run()方法
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
//new Output().output("输出1"); //也不能new对象，new对象的话，this就不代表同一个对象了
outputer.output3("输出2");
}
}
}).start();
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
new Huchi().init();
}
}
this Output.class
面试题：子线程循环 10 次,接着主线程循环 100,接着又回到子线程循环 10 次,接着再回到主线程又循环 100,如此循环50 次,请写出程序
package java_thread;
import java.util.concurrent.atomic.AtomicInteger;
//张孝祥java面试题28
//子线程循环 10 次,接着主线程循环 100,接着又回到子线程循环 10 次,接着再回到主线程又循环 100,如此循环50 次,请写出程序
public class TraditionalThreadCommunication {
/**
* @param args
*/
public static void main(String[] args) {
final Business business = new Business();
new Thread(
new Runnable() {
@Override
public void run() {
for(int i=1;i<=50;i++){
business.sub(i);
}
}
}
).start();
for(int i=1;i<=50;i++){
business.main(i);
}
}
}
class Business {
private boolean bShouldSub = true;
public synchronized void sub(int i){
while(!bShouldSub){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for(int j=1;j<=10;j++){
System.out.println("sub thread sequence of " + j + ",loop of " + i);
}
bShouldSub = false;
this.notify();
}
public synchronized void main(int i){
while(bShouldSub){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for(int j=1;j<=100;j++){
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
bShouldSub = true;
this.notify();
}
}