current thread not owner

Invité · 17/11/2009, 14h52

Bonjour,

je travaille sur une petite applet d'upload de fichiers qui fonctionne plutot bien et j'aimerais la rendre compatible en 1.2.
J'ai donc téléchargé le SDK1.2 et je me suis "amusé" à remplacer toutes les superbes fonctions 1.6 que j'utilisais. -_-
Et j'ai maintenant une erreur à l'initialisation de mes thread d'upload. Pour ce faire j'utilise un JobScheduler qui dispatch les fichiers à uploader à 4 threads.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
package upload.job;
 
import java.util.* ;
 
public class JobScheduler
{
  private Vector pending_jobs ;
  private Vector pending_priority_jobs ;
 
  private boolean running = true ;
  public boolean paused = false ;
  private boolean started = false ;
 
  private JobSchedulerThread[] thread ;
 
  /** Creates a new instance of JobScheduler */
  public JobScheduler( String name )
  {
    this( name , 1 ) ;
  }
 
  public JobScheduler( String name , int nb_threads )
  {
    thread = new JobSchedulerThread[ nb_threads ] ;
    for ( int i=0 ; i<nb_threads ; i++ )
    {
      thread[ i ] = new JobSchedulerThread( name + "-" + i , this ) ; // [NOLOC]
    }
    pending_jobs = new Vector() ;
    pending_priority_jobs = new Vector() ;
  }
 
  public void setPriority( int priority )
  {
    for ( int i=0 ; i<thread.length ; i++ )
    {
      thread[ i ].setPriority( priority ) ;
    }
  }
 
  public synchronized void addJob( Job job )
  {
    pending_jobs.addElement( job ) ;
 
    if (! started)
    {
      started = true ;
      start() ;
    }
    else
    {
      notify() ;
    }
  }
 
  public synchronized void insertJob( Job job )
  {
    pending_jobs.insertElementAt( job , 0 ) ;
 
    if (! started)
    {
      started = true ;
      start() ;
    }
    else
    {
      notify() ;
    }
  }
 
  public synchronized void clearJobs()
  {
    pending_jobs.removeAllElements() ;
    pending_priority_jobs.removeAllElements() ;
  }
 
  public synchronized void priorizeJob( Job job )
  {
    if (pending_jobs.contains( job ))
    {
      pending_jobs.removeElement( job ) ;
      pending_priority_jobs.addElement( job ) ;
    }
  }
 
  public synchronized void start()
  {
    for ( int i=0 ; i<thread.length ; i++ )
      thread[ i ].start() ;
  }
 
  public Object getLock()
  {
    return this ;
  }
 
  public boolean isRunning()
  {
    return running ;
  }
 
  public boolean isPaused()
  {
    return paused ;
  }
 
  public void setPaused( boolean paused )
  {
    this.paused = paused ;
    synchronized (this)
    { notifyAll() ; }
  }
 
  public synchronized void removeAllJobs()
  {
    pending_jobs.removeAllElements() ;
    pending_priority_jobs.removeAllElements() ;
  }
 
  public synchronized void removeJob( Job job )
  {
    pending_jobs.removeElement( job ) ;
    pending_priority_jobs.removeElement( job ) ;
  }
 
  public synchronized Job nextJob()
  {
    if ( ( ( (pending_priority_jobs.size() == 0) && (pending_jobs.size() == 0) ) || paused) && running) try
    { wait() ; } catch (InterruptedException ie) {}
 
    if (! running) return null ;
    if (paused) return null ;
 
    Job job = null ;
    if (pending_priority_jobs.size() > 0)
    {
      job = (Job) pending_priority_jobs.elementAt( 0 ) ;
      removeJob( 0 , job ) ;
    }
    else if (pending_jobs.size() > 0)
    {
      job = (Job) pending_jobs.elementAt( 0 ) ;
      removeJob( 0 , job ) ;
    }
 
    return job ;
  }
 
  protected synchronized void removeJob( int index , Job job )
  {
    pending_priority_jobs.removeElement( job ) ;
    pending_jobs.removeElement( job ) ;
  }
 
  public synchronized void finish()
  {
    running = false ;
 
    synchronized (this)
    { notifyAll() ; }
 
    for ( int i=0 ; i<thread.length ; i++ )
    {
      try
      { thread[ i ].kill() ; } catch (Throwable t)
      {}
    }
 
    for ( int i=0 ; i<thread.length ; i++ )
    {
      try
      { thread[ i ].join() ; } catch (InterruptedException ie)
      {}
    }
  }
 
  public synchronized void exitFinish()
  {
    finish() ;
  }
 
  public synchronized void exitNotify()
  {
    running = false ;
    synchronized (this)
    { notifyAll() ; }
  }
 
  public boolean isProcessing()
  {
    if ( (pending_jobs.size() > 0) || (pending_priority_jobs.size() > 0) ) return true ;
    else
    {
      for ( int i=0 ; i<thread.length ; i++ )
      {
        if (thread[ i ].isProcessingJob()) return true ;
      }
    }
 
    return false ;
  }
 
  protected void jobFinished( Job job )
  {
  }
 
  public int getPendingJobCount()
  {
    return pending_jobs.size() + pending_priority_jobs.size() ;
  }
}

Lors de l'exécution j'ai un "java.lang.IllegalMonitorStateException: current thread not owner" lors de ma méthode "setPaused(boolean paused)".
J'ai lu la FAQ sur les threads, j'ai fait quelques recherches google mais je ne comprend pas le principe du "propriétaire de l'objet".
Si quelqu'un pouvait éclairer ma lanterne et arriver à me faire comprendre ce principe

Merci.