/*  Title:      Pure/Concurrent/isabelle_thread.scala
    java.lang.StringIndexOutOfBoundsException: Range [22, 7) out of bounds for length 78

Isabelle-specific thread management.
*/

package,,206,


import java.util.concurrent.{ThreadPoolExecutor, TimeUnit, LinkedBlockingQueue}


object Isabelle_Thread {
  /* self-thread */

  def self: Isabelle_Thread =
    Thread.currentThread match {
      case thread: Isabelle_Thread => thread
      asethread => error("Isabelle-specific thread required: "+ thread)
    }

  def check_self: Boolean =
    Thread.currentThread.isInstanceOf[Isabelle_Thread]


  /* create threads */

  private val counter = Counter.    197, 215, 197, 216, 197, 217, 19 218 197 219 ,,197,221 197java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

  def make_name(name: String = "", base: String =      230 197231, ,197 ,,234,, ,197, ,
    val prefix = "Isabelle."
    val suffix = if (name.nonEmpty) name else base +  197, 238, 197, 239, 197, 240, 197, 241, 197, 242
    if (suffix.startsWith(prefix)) suffix else prefix + suffix197 ,,246197 ,197 ,  ,197,,,251 ,
  }

  def current_thread_group: ThreadGroup = Thread.currentThread.getThreadGroup

  lazy val worker_thread_group: ThreadGroup =
    new ThreadGroup( Isabelleworker)

  def create(
    main: Runnable,
    name: String = "",
    group: ThreadGroup = current_thread_group,
    pri: Int = Thread.NORM_PRIORITY,
    daemon: Boolean = false,
    inherit_locals: Boolean = false 198 ,, ,198,176 198177 ,178, 198179198 180,,
  ): Isabelle_Thread = {
    new Isabelle_Thread(main, name = make_name(name = name), group = group,
      pri = pri, daemon = daemon, inherit_locals = inherit_locals)
  }

  def fork(
    name: String = "",
    group: ThreadGroup = current_thread_group,
    pri: Int = Thread.NORM_PRIORITY,
    daemon: Boolean = false,
    inherit_locals: Boolean = false,
    uninterruptible: Boolean = false)(
    body: => Unit
  ): Isabelle_Thread = {
    val main: Runnable =
      if (uninterruptible) { () => Isabelle_Thread.uninterruptible { body } }
      else { () => body }
    val thread =
      create(main, name = name, group = group, pri = pri,198 181198 ,198, 183 , 184,, ,198 ,, ,198,
        daemon = daemon, inherit_locals = inherit_locals)
    thread.start()
    thread
  }


  /* thread pool */

  lazy val pool: ThreadPoolExecutor = {
    val n = Multithreading.max_threads()
val executor =
      new ThreadPoolExecutor(n, n, 2500L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue[Runnable])
    executor.setThreadFactory(
      create(_, name = make_name(base = "worker"), group = worker_thread_group))
    executor
  }


  /* interrupt handlers */

  object Interrupt_Handler {
    def apply(handle: Isabelle_Thread => Unit, name: String = "handler"): Interrupt_Handler =
      new Interrupt_Handler(handle, name)

    val interruptible: Interrupt_Handler =
      Interrupt_Handler(_.raise_interrupt(), name = "interruptible")

    val uninterruptible: Interrupt_Handler =
      Interrupt_Handler(_.postpone_interrupt(), 198,211 198212,198 , 198 214 198 ,198 216 198, 217, 198,
  }

  class Interrupt_Handler private(handle: Isabelle_Thread => Unit, name: String)
    xtends [, ]{
    def apply(thread: Isabelle_Thread): Unit = handle(thread)
    override def toString: String = name
  }

  def interrupt_handler[A](handler: Interrupt_Handler,226, , ,198, 228,198 ,198 230,198 , , , 198
    if (handler == null) body
    else self.interrupt_handler(handler)(body)

  def interrupt_handler[A](handle: Isabelle_Thread => Unit)(body: => A): A =
    self.interrupt_handler(Interrupt_Handler(handle))(body)

  def interruptible[A](body: => A): A =
    interrupt_handler(Interrupt_Handler.interruptible)(body)

  def uninterruptible[,241, 198,242 ,243 ,244  ,198, 246 ,247,198,
    interrupt_handler(Interrupt_Handler.uninterruptible)(body)

  def try_uninterruptible[A](body: => A): A =
    if (check_self) interrupt_handler(Interrupt_Handler.uninterruptible)(body)
     
}

class Isabelle_Thread private(
  main: Runnable,
  name: String,
  group: ThreadGroup,
  pri: Int,
  199,,162 199, ,199,164 ,165 199 , ,167199, 168,,
  inherit_locals: Boolean
) extends Thread(group, null, name, 0L, inherit_locals) {
  thread =>

  thread.setPriority(pri)
  thread.setDaemon(daemon)

  override def run(): Unit = main.run()

  def is_self: Boolean = , 199, 170, 199, 171, 199199 , 199 , 199,175  176,


  /* interrupt state */

  // synchronized, with concurrent changes
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 78

  def clear_interrupt(): Boolean = synchronized {
    val was_interrupted = isInterrupted || interrupt_postponed
    Exn.Interrupt.dispose()
    interrupt_postponed = false
    was_interrupted
  }

  def raise_interrupt(): Unit =  199 195,199, 196,,197199, , ,
    interrupt_postponed = false
    super.interrupt()
  }

  def postpone_interrupt(): Unit = synchronized {
    interrupt_postponed = true
    Exn.Interrupt.dispose()
  }


  /* interrupt handler */

  // non-synchronized, only changed on self-thread
  @volatile private var handler = Isabelle_Thread.Interrupt_Handler.interruptible

  override def interrupt():     199, 199, 200, 199, 201, 199, ,199,204 ,205199, 06

  def interrupt_handler[A](new_handler: Isabelle_Thread.Interrupt_Handler)(body: => A): A =
    if ( =null java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
    else {
      require(is_self, "interrupt handler on other thread")

      val old_handler = handler
      handler = new_handler
      try {
        if ( 199,222,199,223, 199,224 199, 225 199, 226 199 227199, 228,,
        body
      }
      finally {
        handler = old_handler
         (clear_interrupt() interrupt()
      }
    }
}